feat: add apt repo and install script installation methods

Add platform-specific installation paths for Elide:

- Debian/Ubuntu: install via the official apt repository (GPG key +
  source list), with version pinning support
- macOS / non-Debian Linux: install via the dl.elide.dev install script
- Windows: keep existing zip/tarball download from dist.elide.zip

Also fixes several pre-existing issues:
- Update download base URL to modern dist.elide.zip scheme
- Strip channel prefix from version tags in download URLs
- Account for bin/ subdirectory in release archives
- Replace unsupported `elide run -c` prewarm with `elide info`
- Add --batch --yes to gpg for non-interactive CI use

Includes unit tests for all new modules (platform detection, apt
installer, script installer, download URL construction) and expands
the CI matrix to test on ubuntu, macos, and windows.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 2 people

.github/workflows/ci.yml

@@ -70,8 +70,12 @@ jobs:
           CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
 
   test-action:
-    name: "Test: Actions"
-    runs-on: ubuntu-latest
+    name: "Test: Actions (${{ matrix.os }})"
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, macos-latest, windows-latest]
 
     steps:
       - name: Harden Runner
@@ -88,9 +92,12 @@ jobs:
         uses: ./
         with: {}
 
-      - name: "Test: Print Output"
-        id: output
-        run: echo "${{ steps.test-action.outputs.path }}"
+      - name: "Test: Verify Installation"
+        shell: bash
+        run: |
+          elide --version
+          echo "Path: ${{ steps.test-action.outputs.path }}"
+          echo "Version: ${{ steps.test-action.outputs.version }}"
 
   check-dist:
     name: "Test: Dist"

__tests__/install-apt.test.ts

@@ -0,0 +1,98 @@
+import * as exec from '@actions/exec'
+import * as io from '@actions/io'
+import * as core from '@actions/core'
+import * as command from '../src/command'
+import { installViaApt } from '../src/install-apt'
+import buildOptions from '../src/options'
+
+describe('install-apt', () => {
+  const execSpy = jest.spyOn(exec, 'exec')
+  const whichSpy = jest.spyOn(io, 'which')
+  const obtainVersionSpy = jest.spyOn(command, 'obtainVersion')
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    // suppress log output
+    jest.spyOn(core, 'info').mockImplementation(() => {})
+    jest.spyOn(core, 'debug').mockImplementation(() => {})
+
+    // default mocks: all exec calls succeed
+    execSpy.mockResolvedValue(0)
+    whichSpy.mockResolvedValue('/usr/bin/elide')
+    obtainVersionSpy.mockResolvedValue('1.0.0')
+  })
+
+  it('should run the correct apt commands for amd64', async () => {
+    const options = buildOptions({
+      os: 'linux',
+      arch: 'amd64',
+      version: 'latest'
+    })
+    const result = await installViaApt(options)
+
+    // GPG key download
+    expect(execSpy).toHaveBeenCalledWith('bash', [
+      '-c',
+      expect.stringContaining('keys.elide.dev/gpg.key')
+    ])
+
+    // apt source with correct arch
+    expect(execSpy).toHaveBeenCalledWith(
+      'sudo',
+      ['tee', '/etc/apt/sources.list.d/elide.list'],
+      expect.objectContaining({
+        input: expect.any(Buffer)
+      })
+    )
+
+    // apt-get update
+    expect(execSpy).toHaveBeenCalledWith('sudo', ['apt-get', 'update', '-qq'])
+
+    // apt-get install elide (no version pin for latest)
+    expect(execSpy).toHaveBeenCalledWith('sudo', [
+      'apt-get',
+      'install',
+      '-y',
+      '-qq',
+      'elide'
+    ])
+
+    expect(result.elidePath).toBe('/usr/bin/elide')
+    expect(result.version.tag_name).toBe('1.0.0')
+  })
+
+  it('should map aarch64 to arm64 for apt', async () => {
+    const options = buildOptions({
+      os: 'linux',
+      arch: 'aarch64',
+      version: 'latest'
+    })
+    await installViaApt(options)
+
+    // Check that the tee call includes arm64
+    const teeCall = execSpy.mock.calls.find(
+      call => call[0] === 'sudo' && call[1]?.[0] === 'tee'
+    )
+    expect(teeCall).toBeDefined()
+    const input = teeCall![2] as { input: Buffer }
+    expect(input.input.toString()).toContain('arch=arm64')
+  })
+
+  it('should pin a specific version when requested', async () => {
+    const options = buildOptions({
+      os: 'linux',
+      arch: 'amd64',
+      version: '1.2.3'
+    })
+    await installViaApt(options)
+
+    expect(execSpy).toHaveBeenCalledWith('sudo', [
+      'apt-get',
+      'install',
+      '-y',
+      '-qq',
+      'elide=1.2.3'
+    ])
+  })
+})

__tests__/install-script.test.ts

@@ -0,0 +1,76 @@
+import * as exec from '@actions/exec'
+import * as io from '@actions/io'
+import * as core from '@actions/core'
+import * as toolCache from '@actions/tool-cache'
+import * as command from '../src/command'
+import { installViaScript } from '../src/install-script'
+import buildOptions from '../src/options'
+
+describe('install-script', () => {
+  const execSpy = jest.spyOn(exec, 'exec')
+  const whichSpy = jest.spyOn(io, 'which')
+  const downloadToolSpy = jest.spyOn(toolCache, 'downloadTool')
+  const obtainVersionSpy = jest.spyOn(command, 'obtainVersion')
+  const addPathSpy = jest.spyOn(core, 'addPath')
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+
+    // suppress log output
+    jest.spyOn(core, 'info').mockImplementation(() => {})
+    jest.spyOn(core, 'debug').mockImplementation(() => {})
+
+    // default mocks
+    downloadToolSpy.mockResolvedValue('/tmp/install.sh')
+    execSpy.mockResolvedValue(0)
+    whichSpy.mockResolvedValue('/usr/local/bin/elide')
+    obtainVersionSpy.mockResolvedValue('1.0.0')
+  })
+
+  it('should download and execute the install script', async () => {
+    const options = buildOptions({
+      os: 'darwin',
+      arch: 'aarch64',
+      version: 'latest'
+    })
+    const result = await installViaScript(options)
+
+    expect(downloadToolSpy).toHaveBeenCalledWith(
+      'https://dl.elide.dev/cli/install.sh'
+    )
+    expect(execSpy).toHaveBeenCalledWith('bash', ['/tmp/install.sh'])
+    expect(result.elidePath).toBe('/usr/local/bin/elide')
+    expect(result.version.tag_name).toBe('1.0.0')
+  })
+
+  it('should pass --version when a specific version is requested', async () => {
+    const options = buildOptions({
+      os: 'linux',
+      arch: 'amd64',
+      version: '1.2.3'
+    })
+    await installViaScript(options)
+
+    expect(execSpy).toHaveBeenCalledWith('bash', [
+      '/tmp/install.sh',
+      '--version',
+      '1.2.3'
+    ])
+  })
+
+  it('should fall back to ~/.elide/bin if which fails initially', async () => {
+    whichSpy
+      .mockRejectedValueOnce(new Error('not found'))
+      .mockResolvedValueOnce('/home/runner/.elide/bin/elide')
+
+    const options = buildOptions({
+      os: 'linux',
+      arch: 'amd64',
+      version: 'latest'
+    })
+    const result = await installViaScript(options)
+
+    expect(addPathSpy).toHaveBeenCalled()
+    expect(result.elidePath).toBe('/home/runner/.elide/bin/elide')
+  })
+})

__tests__/main.test.ts

@@ -1,5 +1,8 @@
 import * as io from '@actions/io'
 import * as core from '@actions/core'
+import * as platform from '../src/platform'
+import * as command from '../src/command'
+import * as installScript from '../src/install-script'
 import * as main from '../src/main'
 import buildOptions, { OptionName } from '../src/options'
 import { ElideArch, ElideOS } from '../src/releases'
@@ -9,6 +12,15 @@ import { resolveExistingBinary } from '../src/main'
 // set timeout to 3 minutes to account for downloads
 jest.setTimeout(3 * 60 * 1000)
 
+// Mock platform-specific installers. The apt and script installers have
+// their own dedicated test suites; here we just need the dispatch to
+// succeed without re-running real installations.
+jest.spyOn(platform, 'isDebianLike').mockResolvedValue(false)
+const scriptSpy = jest.spyOn(installScript, 'installViaScript')
+const prewarmSpy = jest.spyOn(command, 'prewarm')
+const infoSpy = jest.spyOn(command, 'info')
+const obtainVersionSpy = jest.spyOn(command, 'obtainVersion')
+
 // Mock the GitHub Actions core libs
 const getInput = jest.spyOn(core, 'getInput')
 const setFailed = jest.spyOn(core, 'setFailed')
@@ -40,13 +52,23 @@ const action = jest.spyOn(main, 'run')
 describe('action', () => {
   beforeEach(() => {
     jest.clearAllMocks()
+    // Re-apply mocks cleared by clearAllMocks
+    jest.spyOn(platform, 'isDebianLike').mockResolvedValue(false)
+    scriptSpy.mockResolvedValue({
+      version: { tag_name: '1.0.0', userProvided: false },
+      elidePath: '/mock/bin/elide',
+      elideHome: '/mock',
+      elideBin: '/mock/bin'
+    })
+    prewarmSpy.mockResolvedValue(undefined)
+    infoSpy.mockResolvedValue(undefined)
+    obtainVersionSpy.mockResolvedValue('1.0.0')
   })
 
   it('reads option inputs', async () => {
     setupMocks()
     await main.run()
     expect(action).toHaveReturned()
-    expect(action).not.toThrow()
     expect(setFailed).not.toHaveBeenCalled()
     expect(getInput).toHaveBeenCalledWith(OptionName.VERSION)
     expect(getInput).toHaveBeenCalledWith(OptionName.OS)
@@ -67,7 +89,6 @@ describe('action', () => {
 
     await main.run()
     expect(action).toHaveReturned()
-    expect(action).not.toThrow()
     expect(setFailed).not.toHaveBeenCalled()
     expect(setOutput).toHaveBeenCalledWith(
       ActionOutputName.PATH,
@@ -84,10 +105,7 @@ describe('action', () => {
     info.mockImplementationOnce(() => {
       throw new Error('oh noes')
     })
-    const runner = async () => {
-      await main.run()
-    }
-    expect(runner).not.toThrow()
+    await main.run()
     expect(setFailed).toHaveBeenCalled()
   })
 
@@ -144,7 +162,6 @@ describe('action', () => {
       force: true
     })
     expect(action).toHaveReturned()
-    expect(action).not.toThrow()
     expect(setFailed).not.toHaveBeenCalled()
     expect(setOutput).toHaveBeenCalledWith(
       ActionOutputName.PATH,
@@ -163,7 +180,6 @@ describe('action', () => {
       version: '1.0.0-alpha9'
     })
     expect(action).toHaveReturned()
-    expect(action).not.toThrow()
     expect(setFailed).not.toHaveBeenCalled()
     expect(setOutput).toHaveBeenCalledWith(
       ActionOutputName.PATH,

__tests__/platform.test.ts

@@ -0,0 +1,23 @@
+const mockAccess = jest.fn()
+jest.mock('node:fs/promises', () => ({
+  access: mockAccess
+}))
+
+import { isDebianLike } from '../src/platform'
+
+describe('platform detection', () => {
+  beforeEach(() => {
+    mockAccess.mockReset()
+  })
+
+  it('should return true when /etc/debian_version exists', async () => {
+    mockAccess.mockResolvedValueOnce(undefined)
+    expect(await isDebianLike()).toBe(true)
+    expect(mockAccess).toHaveBeenCalledWith('/etc/debian_version')
+  })
+
+  it('should return false when /etc/debian_version does not exist', async () => {
+    mockAccess.mockRejectedValueOnce(new Error('ENOENT: no such file'))
+    expect(await isDebianLike()).toBe(false)
+  })
+})