Skip to content

[Bug]: IDE crash when launching from devsy with ssh provider #1617

Closed

Description

@GuillaumeSavin

Before submitting

  • I have searched existing issues to confirm this is not a duplicate
  • I am running the latest version of Devsy

What happened?

When I succesfully created the first the workspace ide crashes it is only when I use rebuild option that the ide is able to connect without crashing. But i need each time to rebuild because closing the ide and relaunch it with devsy desktop crash the ide immediatelly

What did you expect to happen instead?

Open ide through devsy desktop with ssh provider without crashand without need to rebuild it each time.

Steps to reproduce

Create a new workspace with ssh provider
Get your project using git clone
Select ide (vscodium in my case)
Let devsy create the devcontainer
IDE crash
rebuild the devcotnainer the ide work

devcontainer.json

{
    "build": {
        "dockerfile": "./Dockerfile"
    },
    "postCreateCommand": "npm ci",
    "postStartCommand": "npm install",
    "overrideCommand": true,
    "workspaceFolder": "/home/ubuntu/${localWorkspaceFolderBasename}",
    "workspaceMount": "source=${localWorkspaceFolder},target=/home/ubuntu/${localWorkspaceFolderBasename},type=bind",
    "mounts": [
        {
            "source": "${localEnv:HOME}/.ssh",
            "target": "/home/ubuntu/.ssh",
            "type": "bind"
        },
        {
            "source": "${localEnv:HOME}/.gitconfig",
            "target": "/home/ubuntu/.gitconfig",
            "type": "bind"
        }
    ],
    "appPort": [5173],
    "portsAttributes": {
        "5173": {
            "label": "Vite dev server ignore list",
            "onAutoForward": "ignore"
        }
    },
    "remoteUser": "ubuntu",
    "customizations": {
        "vscode": {
            "extensions": [
                "docker.docker",
                "christian-kohler.path-intellisense",
                "christian-kohler.npm-intellisense",
                "naumovs.color-highlight",
                "formulahendry.auto-complete-tag",
                "eamodio.gitlens",
                "oderwat.indent-rainbow",
                "ms-ceintl.vscode-language-pack-fr",
                "GitLab.gitlab-workflow",
                "hediet.vscode-drawio"
            ]
        }
    }
}

Error output / logs

How often does this happen?

Every time

Operating system

Windows

Linux distribution (if applicable)

No response

Architecture

AMD64

Desktop app or CLI?

Desktop app

Devsy version

v1.24.0

Devsy provider

SSH

Provider version

v1.1.44

Screenshots

No response

Anything else?

Rebuild the devcontainer seems to repair only one time the opening of the ide

Activity

  1. changed the title [-][Bug]: IDE crash when launching from devsy a second time and after with ssh provider[/-] [+][Bug]: IDE crash when launching from devsy with ssh provider[/+] on Oct 20, 2026
  2. skevetter commented on Oct 31, 2026

    @skevetter
    Contributor

    Investigation and implementation handoff: Windows VSCodium launch failure

    Review date: 30 October 2026. Disposition: not established as fixed. Keep #1617 open.

    PR #1716 merged as 2d01238efa1a87a0ec150a822eacdd1f8245ef3b and is included in v1.25.0-beta.5 and later prereleases. It adds stage-specific diagnostics and preserves launch fallback behavior. It explicitly does not fix or prove the Windows editor-lifetime hypothesis. The latest stable release remains v1.24.0.

    Source baseline: main 9bc12ee041ca854c6f81de95fd8c6e49d7cc028c. No native Windows GUI reproduction was performed in this review. This is the plan for the remaining investigation and implementation, building on the merged diagnostics rather than repeating them.

    1. Verified behavior and limits of the evidence

    Verified finding Source Consequence
    Ordinary Desktop startup submits workspace up --detach and follows task logs. ipc.ts The editor can be launched from a detached worker rather than the Electron process.
    Rebuild uses the separate foreground startWorkspaceAction streaming path. ipc.ts The report that rebuild works is consistent with a process-ownership difference, but it can also reflect recreated container state.
    finalizeUp runs launchIDEPhase before reporting ready and exiting its worker. up.go The timing between IDE dispatch and worker exit is a useful diagnostic boundary.
    Windows workers use a named Job Object with JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE; task cleanup also terminates the owned job. launch_windows.go, process_windows.go, store.go A new editor process that actually belongs to that job can be affected by worker cleanup. Membership of the customer's editor has not been measured.
    runHostCLI validates executable/argv shape and calls subprocess.Run; extension enumeration has a separate complete stdout sink. open.go, capture.go Native Windows executable versus .cmd wrapper behavior needs a real Windows test; filename classification is not execution proof.
    CLI launch failure falls back to the URI handler unless canceled; accepted dispatch returns success. open.go A successful Devsy result does not prove that the IDE stayed alive or connected over SSH.
    The existing generic IDE E2E suite uses --ide-launch=skip. ide.go That suite cannot establish the reported GUI launch acceptance.

    Windows normally associates child processes with their parent's Job Object; actual membership can be queried with IsProcessInJob. This makes the lifetime hypothesis technically grounded, not proven for this customer. See Microsoft's Job Objects documentation.

    The report contains no IDE crash log, Windows event, resolved editor command, Dockerfile or measured process lifetime. “IDE closes,” “editor CLI failed,” and “remote SSH connection failed” must be distinguished before selecting a production change.

    2. T0: reproduce and identify the failing boundary

    Use a native Windows AMD64 test environment. Run command/process regressions in GitHub Actions; use an interactive Windows desktop for visible editor acceptance. Record Devsy Desktop/bundled CLI version, SSH provider version/source, VSCodium version/install type, Open Remote - SSH extension version, remote shell/runtime and the actual tested commit. Start with the current prerelease containing #1716; reproduce against v1.24.0 when needed to establish whether any behavior has changed.

    Use an isolated test home/profile and a test repository. Obtain the missing Dockerfile or construct a documented minimum equivalent with the same remote user and lifecycle commands. Do not treat a newly invented Dockerfile as an exact reproduction of the customer's setup.

    • Create a fresh workspace through Desktop, selecting VSCodium and the SSH provider. Record the task ID and the existing IDE operation, route, stage, class, cli_kind records.
    • Record whether a new editor process/window was created, its PID/start time and exit time, the worker PID/job identity, and whether editor exit coincided with worker completion or later task reconciliation.
    • Query the launched editor's actual membership in the worker's named job. A parent PID alone is insufficient, especially when an existing editor instance accepts a launch request.
    • Collect VSCodium's main/renderer and Open Remote - SSH logs separately. Where Windows records a native crash, record the exception/faulting module. Review private paths, repository URLs, SSH hostnames and credentials before attaching excerpts.
    • Once the failure occurs, check that the workspace/container remains running and independently exercise the configured SSH route. Preserve the failing container while testing; do not rebuild before capturing the difference.
    • Repeat with an editor instance already running, then with no instance running. Record which process owns the window.
    • Run the same workspace from a foreground CLI and from workspace up ... --detach, then compare Desktop's ordinary launch and rebuild. Use the same source, provider, IDE options and container generation wherever possible.
    • Run workspace up ... --ide codium --ide-launch=skip, then manually open the same generated SSH host in VSCodium. This separates workspace preparation from host launch.
    • Finally, vary only extensions and lifecycle commands: start with the minimum remote extension, then the reported customization list; compare the original npm ci/npm install configuration with a minimal fixture. Restore the original configuration for final acceptance.

    Required T0 result:

    Observation Next work
    Editor is in the task's job and dies at worker cleanup; foreground or externally launched editor survives. T2 lifetime correction.
    A stage fails before editor GUI dispatch, particularly native execution of the discovered Windows wrapper. T3 launcher correction.
    Editor process survives but Remote - SSH fails. T4 transport/server correction; do not call this a GUI process crash.
    Editor exits independently of Devsy worker/SSH state, with its own crash/extension failure. Use the native crash/extension evidence to select the actual product boundary or upstream issue.
    Current fixed prerelease passes repeated cases but v1.24.0 fails. Bisect the relevant changed boundary and identify the concrete fixing commit; do not attribute the outcome to diagnostics alone.
    No supported reproduction yet. Publish the completed comparison matrix and the specific missing evidence here. Keep the issue open; do not claim a root cause.

    3. T1: add the missing native regression harness

    These are immediately actionable test changes, independent of which hypothesis wins.

    • Add pkg/ide/vscode/open_windows_test.go with Windows build constraints. Exercise the real command runner using temporary known-flavor executable/wrapper fixtures, not only mocked hostLauncher.run. Cover executable resolution, full extension enumeration, required extension install and remote-folder dispatch.
    • For the wrapper fixture, create a real codium.cmd under a path with spaces and verify that each argument survives unchanged. Include Unicode and characters meaningful to Windows command parsing. A fixture that only classifies a .cmd filename does not satisfy this case.
    • Preserve both original error chains when CLI and URI routes fail; verify successful fallback, cancellation before fallback and single dispatch. Do not log arbitrary editor output or remove the allowlisted invocation validation introduced by fix(ide): stage-specific VS Code-family launch diagnostics (#1617) #1716.
    • Add a native process-lifetime test using the real detached task launch/cleanup mechanism and a controlled long-lived editor stand-in. Record job membership and survival while the worker succeeds, fails or is canceled. The fixture must prove a death/survival difference, rather than mock CreateProcess or Job APIs.
    • Place a full CLI regression under e2e/tests/ide or the existing detached-task E2E area, using a distinct label. Register it in hack/ci/suites.yaml for Windows and run through the current CI tool. Require the expected specs to execute; do not let an unavailable GUI silently count as a pass.
    • Keep GUI acceptance separate from this deterministic subprocess fixture. A sleeping stand-in can prove process ownership behavior but cannot prove VSCodium's SSH extension or remote editor session.

    Use the existing pkg/command task ownership helpers in the fixture. Do not invent a second process registry. Tests must clean up only their owned child processes and test workspace.

    4. T2: implementation contract if Job ownership is confirmed

    Trigger: T0 or the native fixture establishes that an intended persistent editor belongs to a setup worker's job and is terminated by its successful completion/cleanup.

    The required behavior is clear: a successful host editor launch belongs to the user session. Build, install, transport preparation and other task children remain owned by the task and cancellable. Do not remove KILL_ON_JOB_CLOSE, skip task cleanup, detach every subprocess, or weaken the general cancellation policy.

    Use these code boundaries:

    Location Required change after confirmation
    pkg/ide/vscode/open.go:hostLauncher, openViaCLI, runHostCLI Separate short-lived CLI operations (list/install extensions) from persistent GUI dispatch. Keep the former on the bounded task-owned runner. Give GUI dispatch its own platform launch function and test seam.
    New Windows-specific host-launch adapter in pkg/ide/vscode Implement the verified route that leaves the editor outside the setup worker's lifetime. Return only after the OS has accepted that launch, close owned process/thread handles and preserve literal validated arguments. Prove job independence in the native test before choosing this as the implementation.
    cmd/workspace/up/up.go:launchIDEPhase and pkg/ide/opener/opener.go Preserve one launch per requested operation, `auto
    desktop/src/main/ipc.ts and workspace-jobs.ts, only if the verified solution transfers dispatch to the initiating Desktop process Claim dispatch using the existing context/workspace/command-generation ownership. Wait for a successful setup result; canceled or superseded operations must never launch an editor. Launch exactly once across duplicate result/follower replay.
    pkg/task/task.go, cmd/workspace/task.go:resultEnvelopeFrom, and shared Desktop parsing, only if a launch request must cross that boundary Add a typed optional request containing validated workspace identity, IDE flavor, folder and window policy. Preserve old task/result compatibility. No raw executable/shell command from a project. Round-trip both direct and task-log result paths.

    The Windows mechanism must be selected from measured evidence, including parent/nested job behavior. DETACHED_PROCESS or CREATE_NEW_PROCESS_GROUP alone must not be treated as proof of Job Object independence. An Electron-only fix is incomplete if direct CLI --detach still launches an editor into the worker's lifetime.

    Before implementing this branch, attach a short design result here stating the chosen Windows API/owner boundary, supported direct/detached/Desktop routes and a native fixture that demonstrates independence. The investigation cannot honestly preselect an OS launch mechanism without that measurement. Keep this as one bounded follow-up under #1617.

    5. T3/T4: narrower implementation branches

    T3. If executable or wrapper dispatch is the cause

    • Correct pkg/ide/vscode/open.go:resolveCLI/runHostCLI through a Windows-specific adapter, retaining OpenParams and the public vscode.Open API.
    • Prefer the editor's supported executable entrypoint where the measured installation provides one. If the installation requires a batch wrapper, use a fixed Windows interpreter and explicitly tested argv encoding for the already allowed operations. Do not interpolate an arbitrary folder URI or executable into a general shell command.
    • Keep full functional extension-list stdout separate from bounded diagnostic capture. Preserve error classification, operation correlation, cancellation and URI fallback.
    • The native regression must fail against the old implementation and pass with the exact wrapper/installation type that failed. Test spaces, Unicode, empty/missing executable, denied launch and literal folder URI data.
    • Keep process-lifetime assertions too. Fixing a wrapper failure does not establish that a newly launched GUI survives task completion.

    T4. If the IDE stays alive and the remote connection fails

    • Use the generated SSH config and existing debug records to identify the first failed hop: Windows ProxyCommand, provider bootstrap, agent handshake, container user/session or editor-side server.
    • Inspect pkg/ssh/config.go, pkg/tunnel, the actual SSH provider bootstrap, and the matching IDE server setup only after the logs identify that hop. Compare ordinary start with rebuild without changing multiple variables.
    • Write a regression at that boundary using the customer's remote shell, user, workspace path and resume sequence. Use known sanitized fixture paths and the existing GitHub Actions SSH suites.
    • Preserve workspace data and correct running/stopped reuse behavior. A workaround that always rebuilds, deletes IDE state blindly or relaxes SSH host-key validation does not meet the requested outcome.
    • Document the exact failed command/state and fixing file/function here before opening the implementation PR. Reuse already merged SSH/provider fixes where applicable instead of duplicating them.

    6. Acceptance and closure

    Scenario Required result
    Fresh Desktop create over SSH, no editor running VSCodium window opens, connects to the correct remote folder and remains usable after the Devsy setup worker exits.
    Close editor and reopen ten times Each launch reconnects without rebuild or loss of workspace files; no extra stale editor/task processes.
    Existing editor instance Correct remote folder/window policy is honored without killing or disrupting an unrelated window.
    Foreground CLI and detached CLI Both support the same persistent editor outcome, with correct exit/result behavior.
    Stop/start and Desktop rebuild Both work; rebuilding is no longer required as a launch workaround.
    Cancellation/racing reopen Canceled or superseded setup does not launch a late editor; legitimate already opened user-session editors are not killed by unrelated task cleanup.
    Setup/extension/dispatch failure Existing stage-specific error remains actionable and bounded; failed setup never reports remote editor success.
    Original project configuration The actual remote user, mounts, hooks and extensions either pass or yield a specifically diagnosed independent failure.

    Retain evidence for the actual supported Windows/VSCodium/SSH-provider versions. Update the existing editor launch troubleshooting section with the confirmed correction and first fixed release, preserving the distinction between dispatch, process survival and SSH readiness.

    Deliver the selected correction in signed commits and a Draft PR linked to #1617, with the native regression and full customer flow recorded. #1716 can be cited as the completed diagnostic prerequisite; it is not a reason to close this bug.

  3. skevetter commented on Nov 1, 2026

    @skevetter
    Contributor

    @GuillaumeSavin is the SSH provider still crashing?

  4. GuillaumeSavin commented on Nov 1, 2026

    @GuillaumeSavin
    Author

    I will try the 3rd wegnesday of november ! In any case thanks for your suport !

  5. skevetter commented on Nov 5, 2026

    @skevetter
    Contributor

    Closing as SSH fixes have gone in to the main repo and the ssh provider to address this issue

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    bugSomething isn't working

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions