InstaNode-dev
diff --git a/‎src/api/index.test.ts‎
Lines changed: 189 additions & 0 deletions b/‎src/api/index.test.ts‎
Lines changed: 189 additions & 0 deletions
diff --git a/‎src/api/index.ts‎
Lines changed: 119 additions & 1 deletion b/‎src/api/index.ts‎
Lines changed: 119 additions & 1 deletion
diff --git a/‎src/api/types.ts‎
Lines changed: 47 additions & 0 deletions b/‎src/api/types.ts‎
Lines changed: 47 additions & 0 deletions
@@ -28,6 +28,8 @@ import {
   listAPIKeys,
   listStacks,
   fetchStackFamily,
+  listDeployments,
+  getDeployment,
 } from './index'
 // §10.21: FIXTURE_BILLING / FIXTURE_INVOICES imports retired. The 503
 // fallback paths in fetchBilling() and listInvoices() were removed —
@@ -615,6 +617,193 @@ describe('listStacks() env field', () => {
   })
 })
 
+// ─── listDeployments() — GET /api/v1/deployments adapter ─────────────────
+// The dashboard's /app/deployments surface previously queried listStacks(),
+// which only returned multi-service stacks and therefore showed an empty
+// list for any team that had only ever called POST /deploy/new. The new
+// listDeployments() adapter is the load-bearing fix — it must:
+//   1. hit GET /api/v1/deployments,
+//   2. normalise the server's 'healthy' status → 'running' so the shared
+//      StatusPill renders the live state correctly,
+//   3. swap `env` (env_vars map) and `environment` (scope name) into the
+//      dashboard's vocabulary (env_vars + env), and
+//   4. surface `app_id` / `id` / `url` faithfully so DeployDetailPage can
+//      link back to the row.
+describe('listDeployments()', () => {
+  it('adapts the API response — env_vars + env scope swap, status normalisation', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({
+      ok: true,
+      total: 2,
+      items: [
+        {
+          id: '11111111-1111-1111-1111-111111111111',
+          app_id: '6fffcc21',
+          token: '6fffcc21',
+          url: 'https://6fffcc21.deployment.instanode.dev',
+          status: 'healthy',
+          port: 8080,
+          tier: 'pro',
+          env: { DATABASE_URL: 'postgres://...', NODE_ENV: 'production' },
+          environment: 'production',
+          created_at: '2026-05-12T11:00:00Z',
+          updated_at: '2026-05-12T11:30:00Z',
+        },
+        {
+          id: '22222222-2222-2222-2222-222222222222',
+          app_id: 'abc123',
+          url: 'https://abc123.deployment.instanode.dev',
+          status: 'building',
+          port: 3000,
+          tier: 'hobby',
+          env: { PORT: '3000' },
+          environment: 'staging',
+          created_at: '2026-05-12T11:10:00Z',
+          updated_at: '2026-05-12T11:11:00Z',
+        },
+      ],
+    }))
+    const r = await listDeployments()
+    expect(r.ok).toBe(true)
+    expect(r.total).toBe(2)
+    expect(r.items.length).toBe(2)
+
+    const a = r.items[0]
+    expect(a.id).toBe('11111111-1111-1111-1111-111111111111')
+    expect(a.app_id).toBe('6fffcc21')
+    // 'healthy' on the wire maps to 'running' for the dashboard's StatusPill.
+    expect(a.status).toBe('running')
+    expect(a.url).toBe('https://6fffcc21.deployment.instanode.dev')
+    // Env scope from `environment`; env_vars from `env`.
+    expect(a.env).toBe('production')
+    expect(a.env_vars).toEqual({ DATABASE_URL: 'postgres://...', NODE_ENV: 'production' })
+    expect(a.port).toBe(8080)
+    expect(a.tier).toBe('pro')
+    // last_deploy_at falls back to updated_at when the API doesn't yet
+    // expose a dedicated last-deploy field.
+    expect(a.last_deploy_at).toBe('2026-05-12T11:30:00Z')
+    // Display name falls through to app_id until the API exposes one.
+    expect(a.name).toBe('6fffcc21')
+
+    expect(r.items[1].env).toBe('staging')
+    expect(r.items[1].status).toBe('building')
+  })
+
+  it('hits GET /api/v1/deployments', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({ ok: true, items: [], total: 0 }))
+    await listDeployments()
+    const [url, init] = m.mock.calls[0]
+    expect(String(url)).toContain('/api/v1/deployments')
+    // GET (default method) — no body, no method override.
+    expect(init?.method ?? 'GET').toBe('GET')
+  })
+
+  it('falls back to items.length when total is omitted', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({
+      ok: true,
+      items: [
+        { id: 'd1', app_id: 'd1', status: 'building', port: 80, tier: 'free', env: {}, environment: 'production', created_at: 'x', updated_at: 'x' },
+      ],
+    }))
+    const r = await listDeployments()
+    expect(r.total).toBe(1)
+  })
+
+  it('returns env_vars: {} when env_vars / env map are omitted', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({
+      ok: true,
+      items: [{
+        id: 'd1', app_id: 'd1', status: 'running', port: 80, tier: 'free',
+        environment: 'production', created_at: 'x', updated_at: 'x',
+      }],
+    }))
+    const r = await listDeployments()
+    expect(r.items[0].env_vars).toEqual({})
+  })
+
+  it('accepts the dedicated env_vars field (forward compat)', async () => {
+    // The audit doc spec listed `env_vars` directly. The live API still
+    // returns env-map under `env`, so we accept either to insulate the
+    // dashboard from the field rename whenever the API ships it.
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({
+      ok: true,
+      items: [{
+        id: 'd1', app_id: 'd1', status: 'running', port: 80, tier: 'pro',
+        environment: 'production',
+        env_vars: { FOO: 'bar' },
+        env: 'production', // string env scope alongside env_vars (forward compat)
+        created_at: 'x', updated_at: 'x',
+      }],
+    }))
+    const r = await listDeployments()
+    expect(r.items[0].env_vars).toEqual({ FOO: 'bar' })
+    expect(r.items[0].env).toBe('production')
+  })
+
+  it('defaults env to "production" when the API omits both fields', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({
+      ok: true,
+      items: [{ id: 'd1', app_id: 'd1', status: 'running', port: 80, tier: 'pro', created_at: 'x', updated_at: 'x' }],
+    }))
+    const r = await listDeployments()
+    expect(r.items[0].env).toBe('production')
+  })
+
+  it('propagates errors so the page can surface them honestly', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({ error: 'list_failed' }, { status: 503 }))
+    await expect(listDeployments()).rejects.toMatchObject({ status: 503 })
+  })
+})
+
+// ─── getDeployment() — single-deploy detail loader ───────────────────────
+describe('getDeployment()', () => {
+  it('returns {ok, deployment} on success', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({
+      ok: true,
+      item: {
+        id: 'd1', app_id: 'd1', status: 'healthy', port: 8080, tier: 'pro',
+        url: 'https://d1.deployment.instanode.dev',
+        env: { DATABASE_URL: 'vault://env/DATABASE_URL' },
+        environment: 'production',
+        created_at: 'x', updated_at: 'y',
+      },
+    }))
+    const r = await getDeployment('d1')
+    expect(r.ok).toBe(true)
+    expect(r.deployment?.id).toBe('d1')
+    expect(r.deployment?.status).toBe('running')
+    expect(r.deployment?.env_vars).toEqual({ DATABASE_URL: 'vault://env/DATABASE_URL' })
+  })
+
+  it('hits GET /api/v1/deployments/:id (URI-encoded)', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({ ok: true, item: { id: 'd weird', app_id: 'd', status: 'running', port: 1, tier: 'free', env: {}, environment: 'production', created_at: 'x', updated_at: 'x' } }))
+    await getDeployment('d weird')
+    expect(String(m.mock.calls[0][0])).toContain('/api/v1/deployments/d%20weird')
+  })
+
+  it('returns {ok:true, deployment: null} on 404 so the page can fall back to the stack lookup', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({ error: 'not_found' }, { status: 404 }))
+    const r = await getDeployment('missing-id')
+    expect(r.ok).toBe(true)
+    expect(r.deployment).toBeNull()
+  })
+
+  it('propagates non-404 errors (e.g. 500)', async () => {
+    const m = installFetch()
+    m.mockResolvedValueOnce(jsonResponse({ error: 'boom' }, { status: 500 }))
+    await expect(getDeployment('d1')).rejects.toMatchObject({ status: 500 })
+  })
+})
+
 // ─── fetchStackFamily() — Pro+ env grid loader ───────────────────────────
 // The discriminated-union return shape is load-bearing for the dashboard's
 // Environments grid: it decides between rendering the grid (ok=true),
 
@@ -8,7 +8,8 @@
 // real error banner instead of lying with mock data.
 
 import type {
-  Resource, DashboardStack, DashboardTeam, BillingDetails, Invoice,
+  Resource, DashboardStack, DashboardDeployment, DeploymentStatus,
+  DashboardTeam, BillingDetails, Invoice,
   TeamMember, TeamInvitation, AuthMeResponse, VaultEntry, ActivityItem
 } from './types'
 
@@ -367,6 +368,123 @@ export async function listStacks(): Promise<{ ok: true; items: DashboardStack[];
   }
 }
 
+// ─── Deployments (LIVE — POST /deploy/new single-container apps) ────────
+//
+// `listDeployments()` hits GET /api/v1/deployments on the agent API and
+// returns the typed dashboard shape. The server response keys collide
+// with DashboardStack vocabulary in one place: it returns `env` for the
+// env-vars map and `environment` for the scope name. We swap them here
+// so the rest of the dashboard can treat env (scope) and env_vars (map)
+// the same way it does for stacks.
+//
+// Status mapping: the server emits 'healthy' for a live deploy, which the
+// dashboard's shared StatusPill renders as 'running' (matching stacks).
+// We normalise here so consumer code doesn't need to special-case it.
+type DeploymentRespItem = {
+  id?: string
+  token?: string
+  app_id?: string
+  url?: string
+  port?: number
+  tier?: string
+  status?: string
+  // Server returns env as a map of env_vars (legacy alias). New callers
+  // should also accept env_vars for forward compat with the spec.
+  env?: Record<string, string> | string
+  env_vars?: Record<string, string>
+  // Env scope (production / staging / dev / ...).
+  environment?: string
+  created_at?: string
+  updated_at?: string
+  last_deploy_at?: string
+  build_duration_s?: number
+  resource_id?: string
+  name?: string
+}
+
+type DeploymentsListResp = {
+  ok: boolean
+  items?: DeploymentRespItem[]
+  total?: number
+}
+
+type DeploymentGetResp = {
+  ok: boolean
+  item?: DeploymentRespItem
+}
+
+function normaliseDeploymentStatus(s: string | undefined): DeploymentStatus {
+  switch (s) {
+    case 'healthy':
+      return 'running' // dashboard's StatusPill speaks 'running'
+    case 'building':
+    case 'deploying':
+    case 'failed':
+    case 'stopped':
+    case 'running':
+      return s
+    default:
+      return 'building'
+  }
+}
+
+function adaptDeployment(d: DeploymentRespItem): DashboardDeployment {
+  // The server's `env` field is the env_vars map (legacy alias); the env
+  // scope name lives under `environment`. New callers may also send a
+  // dedicated `env_vars` field — accept either.
+  const envVarsRaw =
+    d.env_vars ??
+    (typeof d.env === 'object' && d.env !== null ? d.env : undefined)
+  const envScope = d.environment ?? (typeof d.env === 'string' ? d.env : undefined)
+  const id = d.id ?? d.app_id ?? d.token ?? ''
+  const appID = d.app_id ?? d.token ?? id
+  return {
+    id,
+    app_id: appID,
+    // The server doesn't ship a separate display name yet — fall back to
+    // the app_id so the UI has something stable to render. Once the API
+    // exposes a real name, this falls through automatically.
+    name: d.name ?? appID,
+    url: d.url ?? null,
+    status: normaliseDeploymentStatus(d.status),
+    env: (envScope ?? 'production') as DashboardDeployment['env'],
+    port: d.port ?? 0,
+    tier: (d.tier ?? 'free') as DashboardDeployment['tier'],
+    env_vars: envVarsRaw ?? {},
+    created_at: d.created_at ?? '',
+    last_deploy_at: d.last_deploy_at ?? d.updated_at,
+    build_duration_s: d.build_duration_s,
+    resource_id: d.resource_id,
+  }
+}
+
+export async function listDeployments(): Promise<{ ok: true; items: DashboardDeployment[]; total: number }> {
+  // No try/catch fallback to empty — errors propagate so DeploymentsPage
+  // can render a real error state instead of silently lying. The list
+  // endpoint requires auth; 401 still triggers the AuthGate redirect.
+  const r = await call<DeploymentsListResp>('/api/v1/deployments')
+  const items = (r.items ?? []).map(adaptDeployment)
+  return { ok: true, items, total: r.total ?? items.length }
+}
+
+/**
+ * Fetch a single deployment by ID. Returns `null` when the API returns
+ * 404 so the caller (DeployDetailPage) can fall back to the stack lookup
+ * without a noisy console error. Other errors still propagate.
+ */
+export async function getDeployment(
+  id: string,
+): Promise<{ ok: true; deployment: DashboardDeployment | null }> {
+  try {
+    const r = await call<DeploymentGetResp>(`/api/v1/deployments/${encodeURIComponent(id)}`)
+    if (!r.item) return { ok: true, deployment: null }
+    return { ok: true, deployment: adaptDeployment(r.item) }
+  } catch (e: any) {
+    if (e?.status === 404) return { ok: true, deployment: null }
+    throw e
+  }
+}
+
 // ─── Stack family — env-sibling grid ─────────────────────────────────────
 // GET /api/v1/stacks/:slug/family returns root + every direct child as a
 // flat list (root first) so the dashboard can render "production · staging
 
@@ -58,6 +58,53 @@ export interface DashboardStack {
   tier: Tier
 }
 
+// ─── Deployment (POST /deploy/new — single-container app) ───────────────
+//
+// The agent API exposes two deploy surfaces that the dashboard renders
+// through the same pages:
+//   1. multi-service stacks → POST /stacks/new, GET /api/v1/stacks
+//   2. single-container deployments → POST /deploy/new, GET /api/v1/deployments
+//
+// `DashboardDeployment` is the typed shape of (2) after adaptation. The
+// server response includes `env` as a map of env_vars (legacy alias) and
+// `environment` as the env scope name; we surface them as `env_vars` and
+// `env` here so the type matches the DashboardStack vocabulary.
+export type DeploymentStatus =
+  | 'building'
+  | 'deploying'
+  | 'healthy'
+  | 'failed'
+  | 'stopped'
+  // Mapped onto StackStatus for shared UI: 'healthy' → 'running'.
+  | 'running'
+
+export interface DashboardDeployment {
+  /** UUID of the deployment row (used in /deploy/:id paths). */
+  id: string
+  /** Public app token; doubles as the URL slug under deployment.instanode.dev. */
+  app_id: string
+  /** Human-readable name. Server doesn't expose one yet — falls back to app_id. */
+  name: string
+  /** Application URL — e.g. https://<app_id>.deployment.instanode.dev. */
+  url: string | null
+  status: DeploymentStatus
+  /** Env scope: production / staging / dev / ... — defaults to 'production'. */
+  env: Env
+  /** Listening port inside the container. */
+  port: number
+  tier: Tier
+  /** User-supplied env vars (excluding vault refs are still strings). */
+  env_vars: Record<string, string>
+  created_at: string
+  /** Updated_at from the row — used as the "last deploy" timestamp until the
+   *  API exposes a dedicated field. */
+  last_deploy_at?: string
+  /** Not exposed by the API yet; reserved for forward compatibility. */
+  build_duration_s?: number
+  /** Optional resource binding (UUID of the primary resource). */
+  resource_id?: string
+}
+
 export interface DashboardTeam {
   id: string
   name: string