availsync 0.1.0

package/packages/node/src/index.test.ts

@@ -0,0 +1,360 @@
+import {
+  AvailsyncError,
+  createAvailsyncClient,
+  parseResource,
+  type FetchLike,
+} from './index';
+
+function jsonResponse(body: unknown, init: ResponseInit = {}) {
+  return new Response(JSON.stringify(body), {
+    status: init.status ?? 200,
+    headers: { 'content-type': 'application/json', ...(init.headers ?? {}) },
+  });
+}
+
+function makeFetch(responses: Array<Response | Error>) {
+  const calls: Array<{ url: string; init: RequestInit }> = [];
+  const fetchLike: FetchLike = async (url, init = {}) => {
+    calls.push({ url: String(url), init });
+    const next = responses.shift();
+    if (!next) throw new Error('No mocked response available');
+    if (next instanceof Error) throw next;
+    return next;
+  };
+  return { fetchLike, calls };
+}
+
+describe('@availsync/node', () => {
+  test('parses repo and project resource strings', () => {
+    expect(parseResource('repo:owner/repo')).toEqual({
+      resourceType: 'repo',
+      resourceKey: 'owner/repo',
+    });
+    expect(parseResource('project:homepage')).toEqual({
+      resourceType: 'project',
+      resourceKey: 'homepage',
+    });
+  });
+
+  test('rejects invalid resource strings before making requests', async () => {
+    const { fetchLike, calls } = makeFetch([]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+
+    await expect(client.work.start({ resource: 'owner/repo' })).rejects.toMatchObject({
+      code: 'invalid_resource',
+    });
+    expect(calls).toHaveLength(0);
+  });
+
+  test('start sends expected headers and work run payload', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'proceed',
+        claim: { id: 'claim-1', expires_at: '2026-05-13T10:45:00.000Z' },
+        resource: { resource_type: 'repo', resource_key: 'owner/repo' },
+        reason: 'Work slot claimed',
+      }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      baseUrl: 'https://availsync.test/',
+      fetch: fetchLike,
+    });
+
+    const result = await client.work.start({
+      resource: 'repo:owner/repo',
+      durationMinutes: 45,
+      reason: 'scheduled Codex run',
+      idempotencyKey: 'run-1',
+      metadata: { source: 'test' },
+    });
+
+    expect(result.action).toBe('proceed');
+    expect(calls).toHaveLength(1);
+    expect(calls[0].url).toBe('https://availsync.test/v1/work/run/start');
+    expect(calls[0].init.method).toBe('POST');
+    expect(calls[0].init.headers).toMatchObject({
+      Authorization: 'Bearer avs_live_test_secret',
+      'Content-Type': 'application/json',
+      'Idempotency-Key': 'run-1',
+    });
+    expect(JSON.parse(String(calls[0].init.body))).toMatchObject({
+      agent_id: 'agent-1',
+      resource_type: 'repo',
+      resource_key: 'owner/repo',
+      duration_minutes: 45,
+      reason: 'scheduled Codex run',
+      client_name: '@availsync/node',
+      metadata: { source: 'test' },
+    });
+  });
+
+  test('withClaim does not run callback when start returns skip_run', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'skip_run',
+        reason: 'Another agent is already working',
+        retry_after: '2026-05-13T11:00:00.000Z',
+        blocking_claim: { id: 'claim-blocking' },
+      }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+    const callback = jest.fn();
+
+    const result = await client.work.withClaim('repo:owner/repo', { reason: 'test' }, callback);
+
+    expect(result).toMatchObject({
+      action: 'skip_run',
+      reason: 'Another agent is already working',
+      blockingClaim: { id: 'claim-blocking' },
+    });
+    expect(callback).not.toHaveBeenCalled();
+    expect(calls).toHaveLength(1);
+  });
+
+  test('withClaim runs callback on proceed and finishes claim afterwards', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'proceed',
+        claim: { id: 'claim-1', expires_at: '2026-05-13T10:45:00.000Z' },
+        resource: { resource_type: 'repo', resource_key: 'owner/repo' },
+      }),
+      jsonResponse({
+        action: 'finished',
+        claim: { id: 'claim-1', status: 'released' },
+      }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+
+    const result = await client.work.withClaim('repo:owner/repo', { reason: 'test' }, async () => 'done');
+
+    expect(result).toMatchObject({ action: 'proceed', result: 'done' });
+    expect(calls).toHaveLength(2);
+    expect(calls[1].url).toBe('https://availsync.dev/v1/work/run/finish');
+    expect(JSON.parse(String(calls[1].init.body))).toMatchObject({
+      claim_id: 'claim-1',
+      outcome: 'finished',
+      client_name: '@availsync/node',
+    });
+  });
+
+  test('withClaim runs callback in observe mode without finishing a null claim', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'proceed',
+        claim: null,
+        resource: { resource_type: 'repo', resource_key: 'owner/repo' },
+        reason: 'Observe-only mode lets the run proceed',
+        shadow_mode: true,
+        would_have_blocked: true,
+        shadow_decision: {
+          action: 'skip_run',
+          reason: 'Another agent is already working',
+          retry_after: '2026-05-13T11:00:00.000Z',
+          blocking_claim: { id: 'claim-blocking' },
+          rule_applied: 'priority',
+        },
+      }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+    const callback = jest.fn(async ({ claim, shadow }) => {
+      expect(claim).toBeNull();
+      expect(shadow.wouldHaveBlocked).toBe(true);
+      return 'observed';
+    });
+
+    const result = await client.work.withClaim('repo:owner/repo', { reason: 'test' }, callback);
+
+    expect(result).toMatchObject({
+      action: 'proceed',
+      claim: null,
+      result: 'observed',
+      shadowMode: true,
+      wouldHaveBlocked: true,
+      shadowDecision: {
+        action: 'skip_run',
+        blocking_claim: { id: 'claim-blocking' },
+      },
+    });
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(calls).toHaveLength(1);
+  });
+
+  test('withClaim finishes claim after callback throws and rethrows original error', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'proceed',
+        claim: { id: 'claim-1', expires_at: '2026-05-13T10:45:00.000Z' },
+        resource: { resource_type: 'repo', resource_key: 'owner/repo' },
+      }),
+      jsonResponse({
+        action: 'finished',
+        claim: { id: 'claim-1', status: 'released' },
+      }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+    const original = new Error('agent failed');
+
+    await expect(
+      client.work.withClaim('repo:owner/repo', { reason: 'test' }, async () => {
+        throw original;
+      }),
+    ).rejects.toBe(original);
+    expect(calls).toHaveLength(2);
+    expect(JSON.parse(String(calls[1].init.body))).toMatchObject({
+      claim_id: 'claim-1',
+      outcome: 'error',
+    });
+  });
+
+  test('withClaim does not mark successful work as error when finished cleanup fails', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'proceed',
+        claim: { id: 'claim-1', expires_at: '2026-05-13T10:45:00.000Z' },
+        resource: { resource_type: 'repo', resource_key: 'owner/repo' },
+      }),
+      jsonResponse({ error: 'internal_error', message: 'finish failed' }, { status: 500 }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+
+    await expect(
+      client.work.withClaim('repo:owner/repo', { reason: 'test' }, async () => 'done'),
+    ).rejects.toMatchObject({
+      code: 'internal_error',
+      status: 500,
+    });
+    expect(calls).toHaveLength(2);
+    expect(JSON.parse(String(calls[1].init.body))).toMatchObject({
+      claim_id: 'claim-1',
+      outcome: 'finished',
+    });
+  });
+
+  test('withClaim preserves callback error when error cleanup also fails', async () => {
+    const { fetchLike, calls } = makeFetch([
+      jsonResponse({
+        action: 'proceed',
+        claim: { id: 'claim-1', expires_at: '2026-05-13T10:45:00.000Z' },
+        resource: { resource_type: 'repo', resource_key: 'owner/repo' },
+      }),
+      jsonResponse({ error: 'internal_error', message: 'finish failed' }, { status: 500 }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+    const original = new Error('agent failed first');
+
+    await expect(
+      client.work.withClaim('repo:owner/repo', { reason: 'test' }, async () => {
+        throw original;
+      }),
+    ).rejects.toBe(original);
+    expect(calls).toHaveLength(2);
+    expect(JSON.parse(String(calls[1].init.body))).toMatchObject({
+      claim_id: 'claim-1',
+      outcome: 'error',
+    });
+  });
+
+  test('extend and finish map API responses', async () => {
+    const { fetchLike } = makeFetch([
+      jsonResponse({
+        action: 'extended',
+        claim: { id: 'claim-1', renewal_count: 1 },
+        expires_at: '2026-05-13T11:00:00.000Z',
+      }),
+      jsonResponse({
+        action: 'already_finished',
+        claim: { id: 'claim-1', status: 'released' },
+      }),
+    ]);
+    const client = createAvailsyncClient({
+      apiKey: 'avs_live_test_secret',
+      agentId: 'agent-1',
+      fetch: fetchLike,
+    });
+
+    await expect(client.work.extend('claim-1', { durationMinutes: 30 })).resolves.toMatchObject({
+      action: 'extended',
+      claim: { id: 'claim-1' },
+    });
+    await expect(client.work.finish('claim-1')).resolves.toMatchObject({
+      action: 'already_finished',
+      claim: { id: 'claim-1' },
+    });
+  });
+
+  test('API and network failures become AvailsyncError without exposing secrets', async () => {
+    const api = createAvailsyncClient({
+      apiKey: 'secret-api-key',
+      agentId: 'agent-1',
+      fetch: makeFetch([
+        jsonResponse({ error: 'invalid_key', message: 'Invalid API key' }, { status: 401 }),
+      ]).fetchLike,
+    });
+
+    const apiError = await api.work.start({ resource: 'repo:owner/repo' }).catch((error) => error);
+    expect(apiError).toMatchObject({
+      name: 'AvailsyncError',
+      status: 401,
+      code: 'invalid_key',
+    });
+    expect(String(apiError.message)).not.toContain('secret-api-key');
+
+    const network = createAvailsyncClient({
+      apiKey: 'secret-api-key',
+      agentId: 'agent-1',
+      fetch: makeFetch([new Error('connect ECONNREFUSED')]).fetchLike,
+    });
+
+    const networkError = await network.work.start({ resource: 'repo:owner/repo' }).catch((error) => error);
+    expect(networkError).toBeInstanceOf(AvailsyncError);
+    expect(String(networkError.message)).not.toContain('secret-api-key');
+  });
+
+  test('requests time out with a typed AvailsyncError', async () => {
+    const fetchLike: FetchLike = async (_url, init = {}) =>
+      new Promise((_resolve, reject) => {
+        init.signal?.addEventListener('abort', () => reject(new Error('aborted')), { once: true });
+      });
+    const client = createAvailsyncClient({
+      apiKey: 'secret-api-key',
+      agentId: 'agent-1',
+      timeoutMs: 1,
+      fetch: fetchLike,
+    });
+
+    await expect(client.work.start({ resource: 'repo:owner/repo' })).rejects.toMatchObject({
+      code: 'timeout',
+      status: null,
+    });
+  });
+});