mirror of
https://github.com/hanzo-inc/tabs.git
synced 2026-11-10 03:09:32 +00:00
createSandbox picked its project against the running list, while the server refuses a project to a second lease whenever a sandbox holds it, running, pending or parked. A desktop parks when its lease runs out and keeps its disk, so the next New desktop asked for desk-1 and was refused 409 on every press.
287 lines
13 KiB
TypeScript
287 lines
13 KiB
TypeScript
import { readFileSync } from 'node:fs';
|
|
import { join } from 'node:path';
|
|
|
|
import { API, Refusal, createSandbox, frameUrl, grant, machineName, unfunded } from '@/lib/api';
|
|
|
|
/**
|
|
* A sandbox joins the workspace as a machine whose URLs are MINTED, not
|
|
* published — the one contract every Hanzo surface frames (a single-use
|
|
* thirty-second ticket, and the page the mint names). These pin the properties
|
|
* that would fail silently: the URL's only credential is the ticket, the address
|
|
* asked for is the address opened, and a pane never mints twice for one bind.
|
|
*/
|
|
describe('the framed URL', () => {
|
|
const mint = (url: string, ok = true) => {
|
|
const calls: { url: string; init?: RequestInit }[] = [];
|
|
global.fetch = (async (u: string, init?: RequestInit) => {
|
|
calls.push({ url: String(u), init });
|
|
return { ok, status: ok ? 201 : 409, json: async () => ({ url }) };
|
|
}) as unknown as typeof fetch;
|
|
return calls;
|
|
};
|
|
|
|
it('asks the door it wants and frames the address that door answered', async () => {
|
|
const calls = mint('/v1/sandboxes/box%201/terminal?ticket=tk%2B');
|
|
const got = await frameUrl('bearer', 'box 1', 'terminal', 'build');
|
|
expect(calls[0]!.url).toBe(`${API}/v1/sandboxes/box%201/terminal/ticket`);
|
|
expect(calls[0]!.init!.method).toBe('POST');
|
|
const u = new URL(got);
|
|
expect(u.origin).toBe(new URL(API).origin);
|
|
expect(u.pathname).toBe('/v1/sandboxes/box%201/terminal');
|
|
expect(u.searchParams.get('ticket')).toBe('tk+');
|
|
expect(u.searchParams.get('arg')).toBe('build');
|
|
expect([...u.searchParams.keys()].sort()).toEqual(['arg', 'ticket']);
|
|
});
|
|
|
|
it('mints a SCREEN at the screen door, and gives it no shell name to attach to', async () => {
|
|
// A machine has one display. An `arg` here would be a tmux session name sent
|
|
// to something that has no tmux.
|
|
const calls = mint('/v1/sandboxes/b/screen?ticket=tk');
|
|
const got = await frameUrl('bearer', 'b', 'screen');
|
|
expect(calls[0]!.url).toBe(`${API}/v1/sandboxes/b/screen/ticket`);
|
|
expect(new URL(got).pathname).toBe('/v1/sandboxes/b/screen');
|
|
expect([...new URL(got).searchParams.keys()]).toEqual(['ticket']);
|
|
});
|
|
|
|
it('never carries a bearer — the ticket IS the credential', async () => {
|
|
mint('/v1/sandboxes/b/terminal?ticket=tk');
|
|
const u = await frameUrl('a-real-looking-bearer-token', 'b', 'terminal', 's');
|
|
expect(u).not.toMatch(/token|bearer|authorization/i);
|
|
});
|
|
|
|
it('refuses to frame anything when the mint refuses', async () => {
|
|
mint('/v1/sandboxes/b/screen?ticket=tk', false);
|
|
await expect(frameUrl('t', 'b', 'screen')).rejects.toThrow('screen ticket → 409');
|
|
});
|
|
});
|
|
|
|
/**
|
|
* A linked machine's tunnel, handed the identity this browser already holds.
|
|
*
|
|
* The tunnel is gated on hanzo.id, and hanzo.id refuses to be framed — so the
|
|
* gate's own redirect could never run inside a pane, and the workspace used to
|
|
* offer a second sign-in in a second tab for a session that already existed.
|
|
* The grant is that redirect, skipped: one ask, with the token this page reads
|
|
* the registry with, and the tunnel answers with the session.
|
|
*/
|
|
describe('the grant on a linked machine', () => {
|
|
const answers = (res: Partial<Response>) => {
|
|
const calls: { url: string; init?: RequestInit }[] = [];
|
|
global.fetch = (async (u: string, init?: RequestInit) => {
|
|
calls.push({ url: String(u), init });
|
|
return { ok: false, status: 0, type: 'basic', ...res };
|
|
}) as unknown as typeof fetch;
|
|
return calls;
|
|
};
|
|
|
|
it('asks the tunnel itself, with the bearer, for a cookie it may keep', async () => {
|
|
const calls = answers({ ok: true, status: 204 });
|
|
await grant('bearer', 'https://g3q84fzbgfpy.share.hanzo.ai');
|
|
expect(calls[0]!.url).toBe('https://g3q84fzbgfpy.share.hanzo.ai/.well-known/zrok/session');
|
|
expect(calls[0]!.init!.method).toBe('POST');
|
|
expect((calls[0]!.init!.headers as Record<string, string>).Authorization).toBe('Bearer bearer');
|
|
// Without this the browser discards the Set-Cookie and the pane, which
|
|
// carries no bearer of its own, is refused on its very next request.
|
|
expect(calls[0]!.init!.credentials).toBe('include');
|
|
});
|
|
|
|
it('never follows the sign-in it exists to avoid', async () => {
|
|
// Chasing the 302 lands on hanzo.id — the page that cannot be framed and
|
|
// must not be visited on a person's behalf.
|
|
const calls = answers({ ok: true, status: 204 });
|
|
await grant('t', 'https://x.share.hanzo.ai');
|
|
expect(calls[0]!.init!.redirect).toBe('manual');
|
|
});
|
|
|
|
it('reports a tunnel that answers with a sign-in rather than a session', async () => {
|
|
answers({ ok: false, type: 'opaqueredirect' as ResponseType });
|
|
await expect(grant('t', 'https://x.share.hanzo.ai')).rejects.toThrow('asked for a sign-in');
|
|
});
|
|
|
|
it('reports a refusal as itself', async () => {
|
|
answers({ ok: false, status: 403, type: 'basic' as ResponseType });
|
|
await expect(grant('t', 'https://x.share.hanzo.ai')).rejects.toThrow('terminal grant → 403');
|
|
});
|
|
});
|
|
|
|
describe('the workspace mints once per pane', () => {
|
|
const src = readFileSync(join(process.cwd(), 'components/workspace.tsx'), 'utf8');
|
|
|
|
it('stores the minted URL as pane state, never re-derives it per render', () => {
|
|
// A ticket is spent by the frame's first load; deriving the URL on render
|
|
// would hand the iframe a dead credential on the next paint.
|
|
expect(src).toContain('minted[id] ?? null');
|
|
expect(src).toContain('minting.current.has(id)');
|
|
});
|
|
|
|
it('has ONE source for a pane URL, whichever kind of machine serves it', () => {
|
|
// The workspace used to fork: minted for a sandbox, derived from the
|
|
// published tunnel for a linked machine — which is what left the linked
|
|
// one framing a URL nobody had authorised, and a person staring at a
|
|
// second sign-in. Both are minted now, so there is one path to be right.
|
|
//
|
|
// A page is the one pane with no machine and so no credential: its url IS
|
|
// its binding. That is a different question, not a second answer to this
|
|
// one — every pane that has a machine still reads the mint and nothing else.
|
|
expect(src).toContain("b.kind === 'page' ? b.url : (minted[id] ?? null)");
|
|
expect(src).not.toContain('shellUrl(');
|
|
expect(src).not.toMatch(/host\?\.sandbox\s*\?/);
|
|
});
|
|
|
|
it('reconnect forgets the spent URL AND the readiness history', () => {
|
|
expect(src).toContain('setMinted(drop)');
|
|
expect(src).toContain('setAlive(drop)');
|
|
expect(src).toContain('setWaited(drop)');
|
|
});
|
|
|
|
it('a refused pane offers a re-mint, and NEVER a second sign-in', () => {
|
|
// The one rescue, for every pane. A dead credential cannot be reopened in a
|
|
// tab, only asked for again — and sending someone to sign in a second time,
|
|
// as the same person, on another domain, is the defect this replaced.
|
|
expect(src).toMatch(/refused\[id\] \?[\s\S]*?Reconnect/);
|
|
expect(src).not.toMatch(/Sign in to this terminal/);
|
|
expect(src).not.toMatch(/target="_blank"/);
|
|
});
|
|
|
|
it('offers that rescue when the URL never arrived, not only when the frame died', () => {
|
|
// A mint that fails leaves no iframe, so nothing is ever probed and the
|
|
// readiness deadline never fires. Without this the pane says "waiting"
|
|
// forever about a terminal nobody is going to bring.
|
|
expect(src).toMatch(/\.catch\(\(\) => setWaited\(/);
|
|
});
|
|
});
|
|
|
|
describe('a sandbox is named by its project', () => {
|
|
it('goes by the project, which is what its disk is keyed on', () => {
|
|
expect(machineName({ id: 'abcdef123456', status: 'running', project: 'cloud-1' })).toBe('cloud-1');
|
|
});
|
|
|
|
it('falls back to its id, so a projectless box is still openable', () => {
|
|
expect(machineName({ id: 'abcdef123456', status: 'running' })).toBe('cloud-abcdef');
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Starting one. The server keeps ONE live sandbox per project and refuses the
|
|
* rest, so the name is picked against what is already live — which is the whole
|
|
* difference between a second machine and a second attempt at the first.
|
|
*/
|
|
describe('a new cloud machine', () => {
|
|
const calls: { url: string; init?: RequestInit }[] = [];
|
|
const answer = (live: unknown[], made: unknown, ok = true, status = ok ? 201 : 503) => {
|
|
calls.length = 0;
|
|
global.fetch = (async (url: string, init?: RequestInit) => {
|
|
calls.push({ url: String(url), init });
|
|
const body = init?.method === 'POST' ? made : { sandboxes: live };
|
|
return {
|
|
ok: init?.method === 'POST' ? ok : true,
|
|
status,
|
|
json: async () => body,
|
|
};
|
|
}) as unknown as typeof fetch;
|
|
};
|
|
|
|
it('asks for a dev sandbox — the machine you shell into, not a scratch pod', async () => {
|
|
answer([], { id: 'b1', status: 'running', project: 'cloud-1' });
|
|
await createSandbox('t');
|
|
const post = calls.find((c) => c.init?.method === 'POST')!;
|
|
expect(post.url).toBe(`${API}/v1/sandboxes`);
|
|
expect(JSON.parse(String(post.init!.body))).toEqual({ class: 'dev', project: 'cloud-1' });
|
|
});
|
|
|
|
it('asks for a desktop under its OWN name — the project is what the disk is keyed on', async () => {
|
|
// Borrowing the shell machines' project would be the same box's second
|
|
// attempt (one live sandbox per project), not a second box.
|
|
answer([{ id: 'b1', status: 'running', project: 'cloud-1' }], {
|
|
id: 'b2',
|
|
status: 'running',
|
|
project: 'desk-1',
|
|
});
|
|
await createSandbox('t', 'desktop');
|
|
const post = calls.find((c) => c.init?.method === 'POST')!;
|
|
expect(JSON.parse(String(post.init!.body))).toEqual({ class: 'desktop', project: 'desk-1' });
|
|
});
|
|
|
|
it('asks for a browser under its own name, a machine with a real page on its screen', async () => {
|
|
answer([{ id: 'b1', status: 'running', project: 'desk-1' }], { id: 'b2', status: 'running', project: 'web-1' });
|
|
await createSandbox('t', 'browser');
|
|
const post = calls.find((c) => c.init?.method === 'POST')!;
|
|
expect(JSON.parse(String(post.init!.body))).toEqual({ class: 'browser', project: 'web-1' });
|
|
});
|
|
|
|
it('counts past the boxes already live, so pressing twice makes two', async () => {
|
|
answer(
|
|
[
|
|
{ id: 'b1', status: 'running', project: 'cloud-1' },
|
|
{ id: 'b2', status: 'running', project: 'cloud-2' },
|
|
],
|
|
{ id: 'b3', status: 'running', project: 'cloud-3' },
|
|
);
|
|
await createSandbox('t');
|
|
const post = calls.find((c) => c.init?.method === 'POST')!;
|
|
expect(JSON.parse(String(post.init!.body)).project).toBe('cloud-3');
|
|
});
|
|
|
|
it('counts past a PARKED machine, which still holds its disk, and not past an ended one', async () => {
|
|
// A desktop parks when its lease runs out and keeps its project. The server
|
|
// refuses that project to a second lease, parked or not, so taking the name
|
|
// again failed on every press.
|
|
answer(
|
|
[
|
|
{ id: 'b1', status: 'parked', project: 'desk-1' },
|
|
{ id: 'b2', status: 'error', project: 'desk-2' },
|
|
],
|
|
{ id: 'b3', status: 'running', project: 'desk-2' },
|
|
);
|
|
await createSandbox('t', 'desktop');
|
|
const post = calls.find((c) => c.init?.method === 'POST')!;
|
|
expect(JSON.parse(String(post.init!.body))).toEqual({ class: 'desktop', project: 'desk-2' });
|
|
});
|
|
|
|
it("carries the server's reason, because a bare status code names none of them", async () => {
|
|
answer([], { error: 'start sandbox: pod not running after 2m0s' }, false);
|
|
await expect(createSandbox('t')).rejects.toThrow('pod not running after 2m0s');
|
|
});
|
|
|
|
// The refusal a person can actually act on, and the one the fleet spells
|
|
// DIFFERENTLY from every other: money answers a NESTED {error:{code,message}}
|
|
// where other endpoints answer a flat {error:"..."}. Reading only the flat shape
|
|
// coerced that object into a string, so an org out of credit was told
|
|
// "[object Object]" beside a button that had just failed.
|
|
it('reads the money refusal, which is an object and not a sentence', async () => {
|
|
answer(
|
|
[],
|
|
{ error: { code: 'insufficient_balance', message: 'Add credit to start a machine' } },
|
|
false,
|
|
402,
|
|
);
|
|
const e = await createSandbox('t').catch((x) => x);
|
|
expect(e).toBeInstanceOf(Refusal);
|
|
expect(e.message).toBe('Add credit to start a machine');
|
|
expect(e.message).not.toContain('object Object');
|
|
expect(e.code).toBe('insufficient_balance');
|
|
expect(e.status).toBe(402);
|
|
// The whole point of carrying the CODE: the pane branches on it rather than
|
|
// on the sentence, which is free to be reworded.
|
|
expect(unfunded(e)).toBe(true);
|
|
});
|
|
|
|
it('a spend cap is answered the same way — put money on it, or bring a machine', async () => {
|
|
answer([], { error: { code: 'spend_cap_exceeded', message: 'Monthly cap reached' } }, false, 402);
|
|
expect(unfunded(await createSandbox('t').catch((x) => x))).toBe(true);
|
|
});
|
|
|
|
it('every other refusal is NOT a money one, so it offers no remedy it cannot keep', async () => {
|
|
answer([], { error: 'start sandbox: pod not running after 2m0s' }, false, 503);
|
|
const e = await createSandbox('t').catch((x) => x);
|
|
expect(e.message).toContain('pod not running');
|
|
expect(unfunded(e)).toBe(false);
|
|
});
|
|
|
|
it('never sends the bearer to anything but the API', async () => {
|
|
answer([], { id: 'b1', status: 'running', project: 'cloud-1' });
|
|
await createSandbox('t');
|
|
for (const c of calls) expect(c.url.startsWith(API)).toBe(true);
|
|
});
|
|
});
|