@adobe/aio-lib-sandbox 0.1.0-alpha.4 → 0.1.0-alpha.6

package/test/Sandbox.test.js

@@ -14,8 +14,11 @@ const WebSocket = require('ws')
 const Sandbox = require('../src/Sandbox')
 const {
   SandboxClientError,
+  SandboxCommandNotFoundError,
   SandboxInitializationError,
   SandboxNotFoundError,
+  SandboxPortNotProvisionedError,
+  SandboxInvalidPortError,
   SandboxTimeoutError,
   SandboxUnauthorizedError,
   SandboxWebSocketError
@@ -200,7 +203,10 @@ describe('Sandbox', () => {
           wsEndpoint: 'wss://runtime.example.net/ws/v1/namespaces/ns/sandbox/sb-new/exec',
           status: 'ready',
           token: 'tok-new',
-          maxLifetime: 3600
+          maxLifetime: 3600,
+          previewUrls: {
+            3000: 'https://sb-new-3000.preview.example.net'
+          }
         })
       })
       global.fetch = mockFetch
@@ -221,6 +227,9 @@ describe('Sandbox', () => {
 
       expect(sandbox.id).toBe('sb-new')
       expect(sandbox.status).toBe('ready')
+      expect(sandbox.previewUrls).toEqual(new Map([
+        [3000, 'https://sb-new-3000.preview.example.net']
+      ]))
       expect(mockFetch).toHaveBeenCalledWith(
         'https://runtime.example.net/api/v1/namespaces/ns/sandbox',
         expect.objectContaining({ method: 'POST' })
@@ -258,6 +267,42 @@ describe('Sandbox', () => {
       expect(body.policy).toEqual(policy)
     })
 
+    test('forwards ports and populates previewUrls from the response', async () => {
+      const mockFetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          sandboxId: 'sb-ports',
+          wsEndpoint: 'wss://runtime.example.net/ws/v1/namespaces/ns/sandbox/sb-ports/exec',
+          status: 'ready',
+          token: 'tok-ports',
+          maxLifetime: 3600,
+          previewUrls: {
+            3000: 'https://sb-ports-3000.preview.example.net',
+            8080: 'https://sb-ports-8080.preview.example.net'
+          }
+        })
+      })
+      global.fetch = mockFetch
+
+      const createPromise = Sandbox.create({
+        name: 'ports-sandbox',
+        apiHost: 'https://runtime.example.net',
+        namespace: 'ns',
+        auth: 'uuid:key',
+        ports: [3000, 8080]
+      })
+
+      await new Promise(resolve => setImmediate(resolve))
+      sockets[0].open()
+      sockets[0].message({ type: 'auth.ok', sandboxId: 'sb-ports' })
+      const sandbox = await createPromise
+
+      const body = JSON.parse(mockFetch.mock.calls[0][1].body)
+      expect(body.ports).toEqual([3000, 8080])
+      expect(sandbox.getUrl(3000)).toBe('https://sb-ports-3000.preview.example.net')
+      expect(sandbox.getUrl(8080)).toBe('https://sb-ports-8080.preview.example.net')
+    })
+
     test('reads credentials from env vars', async () => {
       process.env.__OW_API_HOST = 'https://runtime.example.net'
       process.env.__OW_NAMESPACE = 'ns'
@@ -385,6 +430,17 @@ describe('Sandbox', () => {
       expect(sockets).toHaveLength(1)
     })
 
+    test('returns the same in-flight promise when called again before auth completes', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      const p1 = sandbox.connect()
+      const p2 = sandbox.connect()
+      expect(p1).toBe(p2)
+      sockets[0].open()
+      sockets[0].message({ type: 'auth.ok', sandboxId: BASE_OPTIONS.id })
+      await Promise.all([p1, p2])
+      expect(sockets).toHaveLength(1)
+    })
+
     test('rejects on auth close code 4001 with SandboxUnauthorizedError', async () => {
       const sandbox = new Sandbox(BASE_OPTIONS)
       const p = sandbox.connect()
@@ -400,6 +456,37 @@ describe('Sandbox', () => {
       sockets[0].closeWith(1006)
       await expect(p).rejects.toThrow(SandboxWebSocketError)
     })
+
+    test('rejects with SandboxWebSocketError on socket error event during connect', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      const p = sandbox.connect()
+      sockets[0].emit('error', new Error('ECONNREFUSED'))
+      await expect(p).rejects.toThrow(SandboxWebSocketError)
+      await expect(p).rejects.toThrow('ECONNREFUSED')
+    })
+
+    test('rejects when auth frame cannot be sent after open', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      const p = sandbox.connect()
+      sockets[0].send = () => { throw new Error('broken auth send') }
+
+      sockets[0].open()
+
+      await expect(p).rejects.toThrow(SandboxWebSocketError)
+      await expect(p).rejects.toThrow('broken auth send')
+    })
+
+    test('resolves in-flight connect when socket is intentionally closed', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      const p = sandbox.connect()
+      const [routeClose] = sockets[0].listeners('close')
+      sockets[0].off('close', routeClose)
+
+      sandbox.ws.beginIntentionalClose()
+      sockets[0].closeWith(1000)
+
+      await expect(p).resolves.toBeUndefined()
+    })
   })
 
   // -------------------------------------------------------------------------
@@ -503,6 +590,18 @@ describe('Sandbox', () => {
       const sandbox = new Sandbox(BASE_OPTIONS)
       await expect(sandbox.exec('cmd')).rejects.toThrow(SandboxWebSocketError)
     })
+
+    test('rejects exec after socket has closed (ws.ensureOpen path)', async () => {
+      const sandbox = await buildConnectedSandbox()
+      sockets[0].closeWith(1006)
+      await expect(sandbox.exec('cmd')).rejects.toThrow(SandboxWebSocketError)
+    })
+
+    test('rejects with SandboxWebSocketError when socket.send throws during exec', async () => {
+      const sandbox = await buildConnectedSandbox()
+      sockets[0].send = () => { throw new Error('broken pipe') }
+      await expect(sandbox.exec('cmd')).rejects.toThrow(SandboxWebSocketError)
+    })
   })
 
   // -------------------------------------------------------------------------
@@ -592,6 +691,18 @@ describe('Sandbox', () => {
 
       await expect(filePromise).rejects.toThrow(SandboxClientError)
     })
+
+    test('rejects when socket is not open', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      await expect(sandbox.readFile('/file.txt')).rejects.toThrow(SandboxWebSocketError)
+    })
+
+    test('rejects when socket.send throws', async () => {
+      const sandbox = await buildConnectedSandbox()
+      sockets[0].send = () => { throw new Error('broken pipe') }
+
+      await expect(sandbox.readFile('/file.txt')).rejects.toThrow(SandboxWebSocketError)
+    })
   })
 
   describe('writeFile()', () => {
@@ -619,6 +730,18 @@ describe('Sandbox', () => {
 
       await expect(writePromise).rejects.toThrow(SandboxClientError)
     })
+
+    test('rejects when socket is not open', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      await expect(sandbox.writeFile('/file.txt', 'content')).rejects.toThrow(SandboxWebSocketError)
+    })
+
+    test('rejects when socket.send throws', async () => {
+      const sandbox = await buildConnectedSandbox()
+      sockets[0].send = () => { throw new Error('broken pipe') }
+
+      await expect(sandbox.writeFile('/file.txt', 'content')).rejects.toThrow(SandboxWebSocketError)
+    })
   })
 
   describe('listFiles()', () => {
@@ -647,6 +770,18 @@ describe('Sandbox', () => {
 
       expect(await listPromise).toEqual([])
     })
+
+    test('rejects when socket is not open', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      await expect(sandbox.listFiles('/workspace')).rejects.toThrow(SandboxWebSocketError)
+    })
+
+    test('rejects when socket.send throws', async () => {
+      const sandbox = await buildConnectedSandbox()
+      sockets[0].send = () => { throw new Error('broken pipe') }
+
+      await expect(sandbox.listFiles('/workspace')).rejects.toThrow(SandboxWebSocketError)
+    })
   })
 
   // -------------------------------------------------------------------------
@@ -654,36 +789,40 @@ describe('Sandbox', () => {
   // -------------------------------------------------------------------------
 
   describe('getUrl()', () => {
-    test('resolves preview URL from template', async () => {
+    test('resolves preview URL from previewUrls map', () => {
       const sandbox = new Sandbox({
         ...BASE_OPTIONS,
-        publicUrlTemplate: 'https://{sandboxId}-{port}.preview.example.net'
+        previewUrls: new Map([[3000, 'https://sb-test-3000.preview.example.net']])
       })
 
-      const url = await sandbox.getUrl({ port: 3000 })
+      const url = sandbox.getUrl(3000)
       expect(url).toBe('https://sb-test-3000.preview.example.net')
     })
 
-    test('replaces scheme when protocol option provided', async () => {
+    test('throws SandboxPortNotProvisionedError when port was not provisioned', () => {
       const sandbox = new Sandbox({
         ...BASE_OPTIONS,
-        publicUrlTemplate: 'https://{sandboxId}-{port}.preview.example.net'
+        previewUrls: new Map([[3000, 'https://sb-test-3000.preview.example.net']])
       })
-
-      const url = await sandbox.getUrl({ port: 3000, protocol: 'wss' })
-      expect(url).toBe('wss://sb-test-3000.preview.example.net')
+      expect(() => sandbox.getUrl(9999)).toThrow(SandboxPortNotProvisionedError)
     })
 
-    test('throws SandboxClientError when publicUrlTemplate is absent', async () => {
-      const sandbox = new Sandbox(BASE_OPTIONS)
-      await expect(sandbox.getUrl({ port: 3000 })).rejects.toThrow(SandboxClientError)
+    test('throws SandboxInvalidPortError for out-of-range port', () => {
+      const sandbox = new Sandbox({
+        ...BASE_OPTIONS,
+        previewUrls: new Map([[3000, 'https://sb-test-3000.preview.example.net']])
+      })
+      expect(() => sandbox.getUrl(0)).toThrow(SandboxInvalidPortError)
+      expect(() => sandbox.getUrl(65536)).toThrow(SandboxInvalidPortError)
     })
 
-    test('throws SandboxClientError for invalid port', async () => {
-      const sandbox = new Sandbox({ ...BASE_OPTIONS, publicUrlTemplate: 'https://{sandboxId}-{port}.preview.example.net' })
-      await expect(sandbox.getUrl({ port: 0 })).rejects.toThrow(SandboxClientError)
-      await expect(sandbox.getUrl({ port: 70000 })).rejects.toThrow(SandboxClientError)
-      await expect(sandbox.getUrl({ port: 'abc' })).rejects.toThrow(SandboxClientError)
+    test('throws SandboxInvalidPortError for non-integer port', () => {
+      const sandbox = new Sandbox({
+        ...BASE_OPTIONS,
+        previewUrls: new Map([[3000, 'https://sb-test-3000.preview.example.net']])
+      })
+      expect(() => sandbox.getUrl('abc')).toThrow(SandboxInvalidPortError)
+      expect(() => sandbox.getUrl(3000.5)).toThrow(SandboxInvalidPortError)
     })
   })
 
@@ -710,6 +849,91 @@ describe('Sandbox', () => {
       )
     })
 
+    test('resolves pending foreground exec when destroy closes the socket', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ status: 'destroyed' })
+      })
+
+      const sandbox = await buildConnectedSandbox()
+      const execPromise = sandbox.exec('sleep 100')
+      const runFrame = JSON.parse(sockets[0].sent[1])
+
+      await sandbox.destroy()
+
+      await expect(execPromise).resolves.toEqual({
+        execId: runFrame.execId,
+        stdout: '',
+        stderr: '',
+        exitCode: null,
+        destroyed: true
+      })
+    })
+
+    test('resolves pending detached exec ack when destroy closes before exec.detached', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ status: 'destroyed' })
+      })
+
+      const sandbox = await buildConnectedSandbox()
+      const commandPromise = sandbox.exec('sleep infinity', { detached: true })
+
+      await sandbox.destroy()
+
+      const command = await commandPromise
+      expect(command).toMatchObject({
+        execId: expect.any(String),
+        pid: undefined,
+        startedAt: undefined,
+        detached: true
+      })
+      await expect(command.wait()).resolves.toEqual({
+        exitCode: null,
+        destroyed: true
+      })
+    })
+
+    test('resolves pending file and getCommand operations when destroy closes socket', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ status: 'destroyed' })
+      })
+
+      const sandbox = await buildConnectedSandbox()
+      const filePromise = sandbox.readFile('/workspace/file.txt')
+      const commandPromise = sandbox.getCommand('exec-running')
+
+      await sandbox.destroy()
+
+      await expect(filePromise).resolves.toBeUndefined()
+      await expect(commandPromise).resolves.toBeNull()
+    })
+
+    test('resolves detached wait when sandbox destroy triggers a 1005 socket close', async () => {
+      const sandbox = await buildConnectedSandbox()
+      global.fetch = jest.fn().mockImplementation(async () => {
+        sockets[0].closeWith(1005)
+        return {
+          ok: true,
+          json: () => Promise.resolve({ status: 'destroyed' })
+        }
+      })
+
+      const commandPromise = sandbox.exec('sleep infinity', { detached: true })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 1234, startedAt: 100 })
+      const command = await commandPromise
+      const waitPromise = command.wait()
+
+      await sandbox.destroy()
+
+      await expect(waitPromise).resolves.toEqual({
+        exitCode: null,
+        destroyed: true
+      })
+    })
+
     test('throws SandboxUnauthorizedError on 403', async () => {
       global.fetch = jest.fn().mockResolvedValue({
         ok: false,
@@ -722,6 +946,297 @@ describe('Sandbox', () => {
     })
   })
 
+  // -------------------------------------------------------------------------
+  // Detached exec
+  // -------------------------------------------------------------------------
+
+  describe('exec() with detached: true', () => {
+    test('sends exec.run with detached:true and resolves with command object on exec.detached', async () => {
+      const sandbox = await buildConnectedSandbox()
+      const chunks = []
+
+      const commandPromise = sandbox.exec('npm run dev', {
+        detached: true,
+        onOutput: (data, stream) => chunks.push({ data, stream })
+      })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+      expect(runFrame.type).toBe('exec.run')
+      expect(runFrame.detached).toBe(true)
+
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 9999, startedAt: 1234567890 })
+
+      const command = await commandPromise
+      expect(command.execId).toBe(runFrame.execId)
+      expect(command.pid).toBe(9999)
+      expect(command.startedAt).toBe(1234567890)
+      expect(command.detached).toBe(true)
+      expect(typeof command.wait).toBe('function')
+      expect(typeof command.kill).toBe('function')
+      expect(typeof command.writeStdin).toBe('function')
+      expect(typeof command.closeStdin).toBe('function')
+    })
+
+    test('command object writeStdin / closeStdin / kill delegate to sandbox', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.exec('tail -f /log', { detached: true })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 42, startedAt: 1000 })
+      const command = await commandPromise
+
+      command.writeStdin('hello\n')
+      const inputFrame = JSON.parse(sockets[0].sent[sockets[0].sent.length - 1])
+      expect(inputFrame.type).toBe('exec.input')
+      expect(inputFrame.execId).toBe(runFrame.execId)
+      expect(inputFrame.data).toBe('hello\n')
+
+      command.closeStdin()
+      const endFrame = JSON.parse(sockets[0].sent[sockets[0].sent.length - 1])
+      expect(endFrame.type).toBe('exec.endInput')
+      expect(endFrame.execId).toBe(runFrame.execId)
+
+      command.kill('SIGINT')
+      const killFrame = JSON.parse(sockets[0].sent[sockets[0].sent.length - 1])
+      expect(killFrame.type).toBe('exec.kill')
+      expect(killFrame.execId).toBe(runFrame.execId)
+      expect(killFrame.signal).toBe('SIGINT')
+    })
+
+    test('wait() resolves with exitCode when exec.exit arrives', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.exec('sleep 100', { detached: true })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 1234, startedAt: 1000000 })
+      const command = await commandPromise
+
+      const waitPromise = command.wait()
+      sockets[0].message({ type: 'exec.exit', execId: runFrame.execId, exitCode: 0 })
+
+      const result = await waitPromise
+      expect(result.exitCode).toBe(0)
+    })
+
+    test('output frames after exec.detached are delivered to onOutput', async () => {
+      const sandbox = await buildConnectedSandbox()
+      const chunks = []
+
+      const commandPromise = sandbox.exec('npm run dev', {
+        detached: true,
+        onOutput: (data, stream) => chunks.push({ data, stream })
+      })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 9000, startedAt: 1 })
+      await commandPromise
+
+      sockets[0].message({ type: 'exec.output', execId: runFrame.execId, stream: 'stdout', data: 'compiled\n' })
+      expect(chunks).toEqual([{ data: 'compiled\n', stream: 'stdout' }])
+    })
+
+    test('rejects with SandboxClientError when timeout is combined with detached', async () => {
+      const sandbox = await buildConnectedSandbox()
+      await expect(
+        sandbox.exec('npm run dev', { detached: true, timeout: 5000 })
+      ).rejects.toThrow(SandboxClientError)
+    })
+
+    test('error frame on detached exec rejects wait()', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.exec('bad-cmd', { detached: true })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+
+      // Resolve outer promise first (process started)
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 1, startedAt: 1 })
+      const command = await commandPromise
+
+      const waitPromise = command.wait()
+      // Then an error arrives (e.g. process crashed with error frame)
+      sockets[0].message({ type: 'error', execId: runFrame.execId, message: 'process crashed' })
+
+      await expect(waitPromise).rejects.toThrow(SandboxClientError)
+    })
+  })
+
+  // -------------------------------------------------------------------------
+  // getCommand
+  // -------------------------------------------------------------------------
+
+  describe('getCommand()', () => {
+    test('sends exec.get and resolves with command object on exec.info', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.getCommand('exec-d1e2f3a4', { onOutput: () => {} })
+      const getFrame = JSON.parse(sockets[0].sent[1])
+      expect(getFrame.type).toBe('exec.get')
+      expect(getFrame.execId).toBe('exec-d1e2f3a4')
+
+      sockets[0].message({
+        type: 'exec.info',
+        execId: 'exec-d1e2f3a4',
+        command: 'npm run dev',
+        pid: 5678,
+        startedAt: 1711036812,
+        detached: true
+      })
+
+      const command = await commandPromise
+      expect(command.execId).toBe('exec-d1e2f3a4')
+      expect(command.command).toBe('npm run dev')
+      expect(command.pid).toBe(5678)
+      expect(command.startedAt).toBe(1711036812)
+      expect(command.detached).toBe(true)
+      expect(typeof command.wait).toBe('function')
+    })
+
+    test('wait() resolves when exec.exit arrives after getCommand()', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.getCommand('exec-reattach')
+      JSON.parse(sockets[0].sent[1]) // exec.get frame
+      sockets[0].message({
+        type: 'exec.info',
+        execId: 'exec-reattach',
+        command: 'sleep 60',
+        pid: 1111,
+        startedAt: 100,
+        detached: true
+      })
+
+      const command = await commandPromise
+      const waitPromise = command.wait()
+
+      sockets[0].message({ type: 'exec.exit', execId: 'exec-reattach', exitCode: 143 })
+      const result = await waitPromise
+      expect(result.exitCode).toBe(143)
+    })
+
+    test('throws SandboxCommandNotFoundError when error NOT_FOUND is returned', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.getCommand('exec-gone')
+      JSON.parse(sockets[0].sent[1])
+      sockets[0].message({
+        type: 'error',
+        execId: 'exec-gone',
+        code: 'NOT_FOUND',
+        message: 'no running process for execId'
+      })
+
+      await expect(commandPromise).rejects.toThrow(SandboxCommandNotFoundError)
+    })
+
+    test('rejects when socket is not open', async () => {
+      const sandbox = new Sandbox(BASE_OPTIONS)
+      await expect(sandbox.getCommand('exec-x')).rejects.toThrow(SandboxWebSocketError)
+    })
+
+    test('rejects and clears pending get operation when socket.send throws', async () => {
+      const sandbox = await buildConnectedSandbox()
+      sockets[0].send = () => { throw new Error('broken pipe') }
+
+      await expect(sandbox.getCommand('exec-x')).rejects.toThrow(SandboxWebSocketError)
+      expect(sandbox.ws.pendingGetOps.has('exec-x')).toBe(false)
+    })
+
+    test('reuses existing wait promise when exec is already running in same session', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      // Start a detached exec so it lands in pendingExecs
+      const commandPromise = sandbox.exec('npm run dev', { detached: true })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 100, startedAt: 1 })
+      const command = await commandPromise
+
+      // Reattach via getCommand for the same execId
+      const getPromise = sandbox.getCommand(runFrame.execId)
+      sockets[0].message({
+        type: 'exec.info',
+        execId: runFrame.execId,
+        command: 'npm run dev',
+        pid: 100,
+        startedAt: 1,
+        detached: true
+      })
+      const reattached = await getPromise
+
+      // Both wait() calls share the same underlying promise
+      const w1 = command.wait()
+      const w2 = reattached.wait()
+      expect(w1).toBe(w2)
+
+      sockets[0].message({ type: 'exec.exit', execId: runFrame.execId, exitCode: 0 })
+      const [r1, r2] = await Promise.all([w1, w2])
+      expect(r1.exitCode).toBe(0)
+      expect(r2.exitCode).toBe(0)
+    })
+
+    test('delivers subsequent output to both original and reattached onOutput callbacks', async () => {
+      const sandbox = await buildConnectedSandbox()
+      const original = []
+      const reattached = []
+
+      const commandPromise = sandbox.exec('npm run dev', {
+        detached: true,
+        onOutput: (data, stream) => original.push({ data, stream })
+      })
+      const runFrame = JSON.parse(sockets[0].sent[1])
+      sockets[0].message({ type: 'exec.detached', execId: runFrame.execId, pid: 1, startedAt: 1 })
+      await commandPromise
+
+      const getPromise = sandbox.getCommand(runFrame.execId, {
+        onOutput: (data, stream) => reattached.push({ data, stream })
+      })
+      sockets[0].message({
+        type: 'exec.info',
+        execId: runFrame.execId,
+        command: 'npm run dev',
+        pid: 1,
+        startedAt: 1,
+        detached: true
+      })
+      await getPromise
+
+      sockets[0].message({ type: 'exec.output', execId: runFrame.execId, stream: 'stdout', data: 'hello\n' })
+      expect(original).toEqual([{ data: 'hello\n', stream: 'stdout' }])
+      expect(reattached).toEqual([{ data: 'hello\n', stream: 'stdout' }])
+    })
+
+    test('command object writeStdin / closeStdin / kill delegate to sandbox', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const getPromise = sandbox.getCommand('exec-xyz')
+      sockets[0].message({
+        type: 'exec.info',
+        execId: 'exec-xyz',
+        command: 'tail -f /log',
+        pid: 42,
+        startedAt: 1000,
+        detached: true
+      })
+      const command = await getPromise
+
+      command.writeStdin('hello\n')
+      const inputFrame = JSON.parse(sockets[0].sent[sockets[0].sent.length - 1])
+      expect(inputFrame.type).toBe('exec.input')
+      expect(inputFrame.execId).toBe('exec-xyz')
+      expect(inputFrame.data).toBe('hello\n')
+
+      command.closeStdin()
+      const endFrame = JSON.parse(sockets[0].sent[sockets[0].sent.length - 1])
+      expect(endFrame.type).toBe('exec.endInput')
+      expect(endFrame.execId).toBe('exec-xyz')
+
+      command.kill('SIGINT')
+      const killFrame = JSON.parse(sockets[0].sent[sockets[0].sent.length - 1])
+      expect(killFrame.type).toBe('exec.kill')
+      expect(killFrame.execId).toBe('exec-xyz')
+      expect(killFrame.signal).toBe('SIGINT')
+    })
+  })
+
   // -------------------------------------------------------------------------
   // Socket close drains pending operations
   // -------------------------------------------------------------------------
@@ -744,5 +1259,25 @@ describe('Sandbox', () => {
 
       await expect(filePromise).rejects.toThrow(SandboxWebSocketError)
     })
+
+    test('rejects pending getCommand when socket closes before exec.info arrives', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      const commandPromise = sandbox.getCommand('exec-running')
+      sockets[0].closeWith(1006)
+
+      await expect(commandPromise).rejects.toThrow(SandboxWebSocketError)
+    })
+
+    test('silently ignores incoming messages with invalid JSON', async () => {
+      const sandbox = await buildConnectedSandbox()
+
+      sockets[0].emit('message', Buffer.from('not-valid-json!!!'))
+
+      const resultPromise = sandbox.exec('echo hi')
+      const frame = JSON.parse(sockets[0].sent[1])
+      sockets[0].message({ type: 'exec.exit', execId: frame.execId, exitCode: 0 })
+      await expect(resultPromise).resolves.toMatchObject({ exitCode: 0 })
+    })
   })
 })

package/.github/workflows/check-npm-token.yml

@@ -1,16 +0,0 @@
-name: check-npm-token
-
-on:
-  workflow_dispatch:
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 24
-          registry-url: 'https://registry.npmjs.org'
-      - run: npm whoami
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.ADOBE_BOT_NPM_TOKEN }}