fix(switchdash): report a missing remote working directory instead of failing at write time (CHOO-1416)

dash/apps/switchdash-desktop/src/main/core/agent-runtime/impl/local-agent-runtime.ts

@@ -167,13 +167,10 @@ export class LocalAgentRuntime implements AgentRuntimeProvider {
         cachedStatePath,
       });
 
-      // A session talks to Switch as its own agent, not whatever identity happens
-      // to sit in `.claude/settings.local.json`. Real env vars outrank every
+      // A session talks to Switch as its own agent. Real env vars outrank every
       // settings file and reach the spawned MCP server, so inject the agent's
       // identity last (highest precedence): a subagent from its definition creds,
-      // and a plain agent from its provider-neutral `.switch/agents/<slug>.json`
-      // (empty when absent — the session then falls back to settings.local.json,
-      // which Claude reads natively).
+      // and a plain agent from its provider-neutral `.switch/agents/<slug>.json`.
       // Resolved before the command is built because a provider that registers
       // the Switch server at launch keys it on this identity (see below).
       const workspaceFs = createPluginFs(this.sessionPath);

dash/apps/switchdash-desktop/src/main/core/agents/add-agent.test.ts

@@ -43,6 +43,10 @@ const h = vi.hoisted(() => {
       apiKey: 'tok-123',
     })),
     createAgent: vi.fn(async (input: Record<string, unknown>) => ({ ...input })),
+    inspectRemoteDir: vi.fn(async (_host: string, dir: string) => ({
+      dir,
+      status: 'directory' as const,
+    })),
   };
 });
 
@@ -65,6 +69,9 @@ vi.mock('@main/core/locations/store', () => ({
   getLocationByHostDir: vi.fn(async () => ({ id: 'loc-1' })),
 }));
 vi.mock('./agent-name-taken', () => ({ agentNameTaken: h.agentNameTaken }));
+// Also keeps ssh-fs (and through it the Electron-bound db) out of this file's
+// module graph.
+vi.mock('./remote-dir', () => ({ inspectRemoteDir: h.inspectRemoteDir }));
 vi.mock('@main/core/locations/path-utils', () => ({ checkIsValidDirectory: () => true }));
 vi.mock('@main/core/locations/location-manager', () => ({
   locationManager: { openLocation: vi.fn(async () => {}) },
@@ -105,6 +112,10 @@ describe('addAgent', () => {
     h.state.repoAgents = { writeDefinition: h.writeDefinition };
     h.state.workspace = fakeFs();
     h.registerAgentIdentity.mockResolvedValue({ kind: 'created', id: 'sw-1', apiKey: 'tok-123' });
+    h.inspectRemoteDir.mockImplementation(async (_host: string, dir: string) => ({
+      dir,
+      status: 'directory' as const,
+    }));
   });
 
   it('writes name-keyed credentials for a provider with no repo-agent definitions', async () => {
@@ -176,4 +187,53 @@ describe('addAgent', () => {
     expect(h.registerAgentIdentity).not.toHaveBeenCalled();
     expect(h.createAgent).not.toHaveBeenCalled();
   });
+
+  describe('remote working directory', () => {
+    const remote = { sshHost: 'louis-1-cluster', dir: '/home/ubuntu/switch-agents/deploys' };
+
+    it('reports a missing remote directory without minting an identity', async () => {
+      // The whole point of checking first: this used to surface as a raw
+      // FileSystemError from the first credentials write, leaving the agent on
+      // the gateway but nowhere else (CHOO-1416).
+      h.inspectRemoteDir.mockResolvedValue({ dir: remote.dir, status: 'missing' } as never);
+
+      const result = await addAgent(params(remote));
+
+      expect(result).toEqual({
+        kind: 'directory-missing',
+        sshHost: remote.sshHost,
+        inspection: expect.objectContaining({ status: 'missing' }),
+      });
+      expect(h.registerAgentIdentity).not.toHaveBeenCalled();
+      expect(h.createAgent).not.toHaveBeenCalled();
+    });
+
+    it('refuses a remote path that is a file', async () => {
+      h.inspectRemoteDir.mockResolvedValue({ dir: remote.dir, status: 'file' } as never);
+
+      expect((await addAgent(params(remote))).kind).toBe('directory-missing');
+      expect(h.registerAgentIdentity).not.toHaveBeenCalled();
+    });
+
+    it('proceeds when the remote directory exists', async () => {
+      const result = await addAgent(params(remote));
+
+      expect(h.inspectRemoteDir).toHaveBeenCalledWith(remote.sshHost, remote.dir);
+      expect(result.kind).toBe('created');
+    });
+
+    // The credentials write creates a leaf under an existing parent by itself,
+    // so gating on "exists" would have broken a path that worked before.
+    it('proceeds when the remote directory does not exist but its parent does', async () => {
+      h.inspectRemoteDir.mockResolvedValue({ dir: remote.dir, status: 'creatable' } as never);
+
+      expect((await addAgent(params(remote))).kind).toBe('created');
+      expect(h.registerAgentIdentity).toHaveBeenCalled();
+    });
+
+    it('does not probe over SSH for a local agent', async () => {
+      await addAgent(params());
+      expect(h.inspectRemoteDir).not.toHaveBeenCalled();
+    });
+  });
 });

dash/apps/switchdash-desktop/src/main/core/agents/add-agent.ts

@@ -9,13 +9,15 @@ import { log } from '@main/lib/logger';
 import type { AgentProviderConfig } from '@shared/core/agents/agent-provider-config';
 import type { Agent } from '@shared/core/agents/agents';
 import type { AgentProviderId } from '@shared/core/providers/agent-provider-registry';
+import { isUsableRemoteDir, type RemoteDirInspection } from '@shared/core/remote-hosts/remote-dir';
 import { basenameFromAnyPath } from '@shared/path-name';
 import { agentEvents } from './agent-events';
 import { agentNameTaken } from './agent-name-taken';
 import { resolveWorkspaceFsFor } from './agent-workspace-fs';
 import { createAgent } from './createAgent';
 import { knownAgentTypeForProvider } from './known-agent-type';
 import { registerAgentIdentity } from './register-agent-identity';
+import { inspectRemoteDir } from './remote-dir';
 import { reconcileAgentAutoSessionFromGateway } from './setAgentAutoSession';
 import { writeNeutralAgentSettingsFs } from './write-switch-settings';
 
@@ -51,6 +53,11 @@ export type AddAgentResult =
   | { kind: 'unauthenticated' }
   | { kind: 'name-conflict' }
   | { kind: 'invalid-name'; message: string }
+  /** The remote working directory is unusable: it is a file, or neither it nor
+   * its parent exists so the credentials write cannot create it. Reported
+   * before anything is minted, so no Switch-side agent is left behind
+   * (CHOO-1416). */
+  | { kind: 'directory-missing'; sshHost: string; inspection: RemoteDirInspection }
   | { kind: 'error'; message: string };
 
 /**
@@ -65,11 +72,28 @@ export type AddAgentResult =
  * written to disk and never returned. A recoverable gateway failure is mapped to
  * a typed result the modal can act on; a filesystem failure after registration
  * throws (leaving the gateway agent, as the pre-existing provision path did).
+ *
+ * Both run locations therefore check the working directory *before* minting the
+ * identity — locally with `checkIsValidDirectory`, remotely with
+ * `inspectRemoteDir`. The remote check refuses only what the write genuinely
+ * cannot handle: a file, or a directory whose parent is missing too. A missing
+ * directory under an existing parent still goes through and is created by the
+ * write, as it always was. The refused case used to surface as a raw
+ * `FileSystemError` from the first credentials write, by which point the agent
+ * existed on the gateway but nowhere else (CHOO-1416). Ordering the check first
+ * removes that orphan for this failure; creation as a whole is still not atomic
+ * (CHOO-1415).
  */
 export async function addAgent(params: AddAgentParams): Promise<AddAgentResult> {
   if (params.sshHost === null && !checkIsValidDirectory(params.dir)) {
     return { kind: 'error', message: `Invalid directory: ${params.dir}` };
   }
+  if (params.sshHost !== null) {
+    const inspection = await inspectRemoteDir(params.sshHost, params.dir);
+    if (!isUsableRemoteDir(inspection)) {
+      return { kind: 'directory-missing', sshHost: params.sshHost, inspection };
+    }
+  }
 
   const server = await getServer(params.serverId);
   if (!server) return { kind: 'error', message: `No Switch server with id ${params.serverId}` };

dash/apps/switchdash-desktop/src/main/core/agents/controller.ts

@@ -1,6 +1,5 @@
 import type { RepoAgentAttributes } from '@switchdash/core/agents/plugins';
 import type { CreateAgentParams, RenameAgentParams } from '@shared/core/agents/agents';
-import type { OnboardAgentParams } from '@shared/core/agents/onboarding';
 import type { AgentProviderId } from '@shared/core/providers/agent-provider-registry';
 import type { AgentVerifyResult } from '@shared/core/switch-servers/switch-servers';
 import { createRPCController } from '@shared/lib/ipc/rpc';
@@ -18,7 +17,6 @@ import { discoverConfiguredAgents } from './discover-configured-agents';
 import { discoverLocationAgents } from './discover-location-agents';
 import { getAgentById } from './getAgentById';
 import { getAgents } from './getAgents';
-import { onboardAgent } from './onboard-agent';
 import { onboardLocationAgents, type OnboardLocationParams } from './onboard-location-agents';
 import { renameAgent } from './renameAgent';
 import { resetRemoteAgent } from './reset-remote-agent';
@@ -38,7 +36,6 @@ export const agentsController = createRPCController({
   readAgentDefinition: (params: { agentId: string }) => readAgentDefinition(params.agentId),
   updateAgentDefinition: (params: { agentId: string; attributes: RepoAgentAttributes }) =>
     updateAgentDefinition(params),
-  onboardAgent: (params: OnboardAgentParams) => onboardAgent(params),
   onboardLocationAgents: (params: OnboardLocationParams) => onboardLocationAgents(params),
   discoverLocationAgents: (params: {
     sshHost: string | null;

dash/apps/switchdash-desktop/src/main/core/agents/deleteAgent.ts

@@ -22,7 +22,6 @@ import { connectRemoteAgent } from './connect-remote-agent';
 import { getAgentById } from './getAgentById';
 import { stopRemoteWatcher } from './remote-watcher';
 import { removeAgentLaunchProfile } from './remove-launch-profile';
-import { removeSwitchCredentials } from './remove-switch-settings';
 import { agentSettingsRelativePath } from './switch-settings-paths';
 
 export type DeleteAgentOptions = {
@@ -96,7 +95,6 @@ async function removeProvisionedFiles(agent: Agent, location: Location): Promise
         error: String(error),
       });
     });
-    await removeSwitchCredentials(agent.providerId, ctx.fs);
     // A provider that registers the Switch server itself (Codex) leaves a
     // per-agent launch profile under the user's home — a different scope than
     // ctx.fs, reached through its own home filesystem (local or remote).