@notis_ai/cli 0.2.12 → 0.2.14

package/src/runtime/git.js

@@ -0,0 +1,233 @@
+/**
+ * Local git inspection for `notis handover`.
+ *
+ * The CLI has no other reason to know about git, so this stays deliberately
+ * small: read where we are, push the branch, and report what the remote is.
+ * Everything else about the repository is the cloud workspace's problem.
+ *
+ * Every call is `spawnSync` on the real `git` binary rather than a library.
+ * The user's credentials, hooks, SSH agent and includeIf config are what make a
+ * push succeed on their machine, and only their own git honors all of them.
+ */
+
+import { spawnSync } from 'node:child_process';
+import { lstatSync, readFileSync } from 'node:fs';
+import { basename, relative, resolve, sep } from 'node:path';
+import { CliError, EXIT_CODES } from './errors.js';
+
+const GIT_TIMEOUT_MS = 120_000;
+const MAX_SECRET_SCAN_BYTES = 1_000_000;
+const SAFE_ENV_TEMPLATES = /^\.env\.(?:example|sample|template)$/i;
+const SENSITIVE_PATH = /^(?:\.env(?:\..+)?|\.envrc|\.git-credentials|\.npmrc|\.pypirc|\.netrc|credentials(?:\..+)?|secrets?(?:\..+)?|id_(?:rsa|dsa|ecdsa|ed25519)(?:\.pub)?|.*\.(?:pem|key|p12|pfx|jks))$/i;
+const SENSITIVE_CONTENT = [
+  /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/,
+  /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/i,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\bgh[pousr]_[A-Za-z0-9]{36,}\b/,
+  /\bsk-[A-Za-z0-9_-]{20,}\b/,
+];
+
+export function runGit(
+  args,
+  { cwd = process.cwd(), timeoutMs = GIT_TIMEOUT_MS, trimOutput = true } = {},
+) {
+  const result = spawnSync('git', args, {
+    cwd,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: {
+      ...process.env,
+      // A push that stops to ask for a password would hang a non-interactive
+      // agent run forever. Fail fast instead and let the hint explain.
+      GIT_TERMINAL_PROMPT: '0',
+    },
+  });
+  if (result.error && result.error.code === 'ENOENT') {
+    throw new CliError({
+      code: 'git_not_found',
+      message: 'git is not installed or not on PATH.',
+      exitCode: EXIT_CODES.usage,
+    });
+  }
+  return {
+    exitCode: result.status ?? 1,
+    stdout: trimOutput ? (result.stdout || '').trim() : (result.stdout || ''),
+    stderr: trimOutput ? (result.stderr || '').trim() : (result.stderr || ''),
+  };
+}
+
+function gitOrNull(args, options) {
+  const result = runGit(args, options);
+  return result.exitCode === 0 ? result.stdout : null;
+}
+
+function nulSeparatedGitPaths(args, repository) {
+  const result = runGit([...args, '-z'], { cwd: repository.toplevel, trimOutput: false });
+  if (result.exitCode !== 0 || !result.stdout) return [];
+  return result.stdout.split('\0').filter(Boolean);
+}
+
+/** Exact files `git add -A` would include, expanding untracked directories. */
+function filesToAutoCommit(repository) {
+  return [...new Set([
+    ...nulSeparatedGitPaths(['diff', '--name-only'], repository),
+    ...nulSeparatedGitPaths(['diff', '--cached', '--name-only'], repository),
+    ...nulSeparatedGitPaths(['ls-files', '--others', '--exclude-standard'], repository),
+  ])];
+}
+
+/** Refuse files that are unsafe to publish automatically without user review. */
+export function sensitiveAutoCommitFiles(repository) {
+  const root = resolve(repository.toplevel);
+  const sensitive = [];
+  for (const path of filesToAutoCommit(repository)) {
+    const absolute = resolve(root, path);
+    const insideRoot = relative(root, absolute);
+    if (insideRoot === '..' || insideRoot.startsWith(`..${sep}`) || insideRoot === '') continue;
+    const name = basename(path);
+    if (SENSITIVE_PATH.test(name) && !SAFE_ENV_TEMPLATES.test(name)) {
+      sensitive.push(path);
+      continue;
+    }
+    try {
+      const stat = lstatSync(absolute);
+      if (!stat.isFile() || stat.size > MAX_SECRET_SCAN_BYTES) continue;
+      const content = readFileSync(absolute, 'utf8');
+      if (SENSITIVE_CONTENT.some((pattern) => pattern.test(content))) sensitive.push(path);
+    } catch {
+      // Deleted files and paths racing with an editor have no content to leak.
+    }
+  }
+  return sensitive;
+}
+
+/**
+ * Parse an origin URL into {owner, repo}. Handles the three forms git remotes
+ * actually take: scp-style ssh, ssh:// and https://.
+ */
+export function parseRemoteUrl(url) {
+  if (typeof url !== 'string' || !url) {
+    return null;
+  }
+  const trimmed = url.trim().replace(/\.git$/, '');
+  const scp = trimmed.match(/^[^@]+@([^:]+):(.+)$/);
+  const path = scp ? scp[2] : trimmed.replace(/^[a-z+]+:\/\/(?:[^@/]+@)?[^/]+\//i, '');
+  const host = scp ? scp[1] : (trimmed.match(/^[a-z+]+:\/\/(?:[^@/]+@)?([^/]+)/i) || [])[1];
+  const segments = path.split('/').filter(Boolean);
+  if (segments.length < 2) {
+    return null;
+  }
+  return {
+    host: host || null,
+    owner: segments[segments.length - 2],
+    repo: segments[segments.length - 1],
+  };
+}
+
+/** Everything `handover start` needs to know about where it is running. */
+export function inspectRepository(cwd = process.cwd()) {
+  const toplevel = gitOrNull(['rev-parse', '--show-toplevel'], { cwd });
+  if (!toplevel) {
+    throw new CliError({
+      code: 'not_a_git_repository',
+      message: 'Hand-over runs from inside a git repository.',
+      exitCode: EXIT_CODES.usage,
+      hints: [{ message: 'cd into the repository you want Notis to work on, then run the command again.' }],
+    });
+  }
+
+  const branch = gitOrNull(['branch', '--show-current'], { cwd: toplevel });
+  if (!branch) {
+    throw new CliError({
+      code: 'detached_head',
+      message: 'HEAD is detached, so there is no branch to hand over.',
+      exitCode: EXIT_CODES.usage,
+      hints: [{ message: 'Check out a branch first: git switch -c my-feature' }],
+    });
+  }
+
+  const remoteUrl = gitOrNull(['remote', 'get-url', 'origin'], { cwd: toplevel });
+  if (!remoteUrl) {
+    throw new CliError({
+      code: 'no_origin_remote',
+      message: 'This repository has no "origin" remote, so the cloud agent cannot fetch the branch.',
+      exitCode: EXIT_CODES.usage,
+      hints: [{ message: 'Add one: git remote add origin <url>' }],
+    });
+  }
+
+  const status = runGit(['status', '--porcelain'], { cwd: toplevel });
+  const dirtyFiles = status.stdout
+    ? status.stdout.split('\n').map((line) => line.slice(3).trim()).filter(Boolean)
+    : [];
+
+  return {
+    toplevel,
+    branch,
+    remoteUrl,
+    remote: parseRemoteUrl(remoteUrl),
+    dirtyFiles,
+    head: gitOrNull(['rev-parse', 'HEAD'], { cwd: toplevel }),
+    upstream: gitOrNull(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}'], {
+      cwd: toplevel,
+    }),
+  };
+}
+
+/** Commit everything in the working tree, including untracked files. */
+export function commitWorkingTree(repository, message) {
+  const sensitiveFiles = sensitiveAutoCommitFiles(repository);
+  if (sensitiveFiles.length) {
+    throw new CliError({
+      code: 'sensitive_working_tree',
+      message: 'Refusing to publish files that may contain credentials or private keys.',
+      exitCode: EXIT_CODES.conflict,
+      details: { sensitive_files: sensitiveFiles.slice(0, 20) },
+      hints: [
+        { message: 'Review, remove, or ignore these files before handing over.' },
+        { message: 'To publish them deliberately, commit and push them yourself first.' },
+      ],
+    });
+  }
+  const add = runGit(['add', '-A'], { cwd: repository.toplevel });
+  if (add.exitCode !== 0) {
+    throw new CliError({
+      code: 'git_add_failed',
+      message: `Could not stage the working tree: ${add.stderr || add.stdout}`,
+      exitCode: EXIT_CODES.unexpected,
+    });
+  }
+  const commit = runGit(['commit', '-m', message], { cwd: repository.toplevel });
+  if (commit.exitCode !== 0) {
+    throw new CliError({
+      code: 'git_commit_failed',
+      message: `Could not commit the working tree: ${commit.stderr || commit.stdout}`,
+      exitCode: EXIT_CODES.unexpected,
+      hints: [{ message: 'Commit the changes yourself, then run the hand-over again.' }],
+    });
+  }
+  return gitOrNull(['rev-parse', 'HEAD'], { cwd: repository.toplevel });
+}
+
+/**
+ * Push the branch to origin. The cloud workspace fetches from origin, so an
+ * unpushed commit simply does not exist as far as the hand-over is concerned.
+ */
+export function pushBranch(repository, branch) {
+  const args = repository.upstream
+    ? ['push', 'origin', branch]
+    : ['push', '--set-upstream', 'origin', branch];
+  const result = runGit(args, { cwd: repository.toplevel });
+  if (result.exitCode !== 0) {
+    throw new CliError({
+      code: 'git_push_failed',
+      message: `Could not push ${branch} to origin: ${result.stderr || result.stdout}`,
+      exitCode: EXIT_CODES.conflict,
+      hints: [
+        { message: 'The cloud agent works from origin, so the branch has to be pushed first.' },
+        { message: 'If the remote moved ahead, reconcile locally (git pull --rebase) and retry.' },
+      ],
+    });
+  }
+  return true;
+}

package/src/runtime/oauth.js

@@ -19,6 +19,11 @@ import { createInterface } from 'node:readline/promises';
 
 import { CliError, EXIT_CODES } from './errors.js';
 import { getAuthRecovery, quoteShellArgument } from './auth-recovery.js';
+import {
+  channelFromProfile,
+  cliCommandForChannel,
+  isReleaseChannel,
+} from './channel.js';
 import {
   credentialIsExpired,
   ensureProfile,
@@ -137,6 +142,12 @@ export async function discoverCliOAuth(apiBase, fetchImpl = fetch) {
     resource: protectedResource.resource,
     clientId: protectedResource.notis_cli_client_id || 'notis_cli',
     copyPasteRedirectUri: protectedResource.notis_cli_copy_paste_redirect_uri,
+    // A deployment that predates channel advertising, or a local one with no
+    // published build, leaves this null and the profile keeps resolving its
+    // channel from the endpoint it authorized against.
+    channel: isReleaseChannel(protectedResource.notis_cli_channel)
+      ? protectedResource.notis_cli_channel
+      : null,
     authorizationEndpoint: authorizationServer.authorization_endpoint,
     tokenEndpoint: authorizationServer.token_endpoint,
     revocationEndpoint: authorizationServer.revocation_endpoint,
@@ -718,6 +729,13 @@ function persistOAuthTokenResponse(runtime, metadata, tokenResponse) {
       // only endpoint the resulting token is accepted by.
       api_base: oauthApiBase || profile.api_base,
       beta: beta ?? profile.beta,
+      // The deployment that just authorized this profile also names the
+      // published build that belongs to it. Pinning it here is what lets the
+      // next run correct itself without the user knowing a channel exists.
+      channel: isReleaseChannel(metadata.channel)
+        ? metadata.channel
+        : channelFromProfile({ ...profile, beta: beta ?? profile.beta, api_base: oauthApiBase })
+          ?? profile.channel,
       oauth_api_base: oauthApiBase || profile.oauth_api_base,
       oauth_resource: metadata.resource,
       oauth_access_token: tokenResponse.access_token,
@@ -784,14 +802,20 @@ function clearPendingAuthorization(runtime, file = pendingAuthorizationFile(runt
   }
 }
 
-function redeemCommand(profileName) {
+function redeemCommand(profileName, channel) {
   return [
-    'npx --package @notis_ai/cli@latest -- notis',
+    cliCommandForChannel(channel),
     `--profile ${quoteShellArgument(profileName || 'default')}`,
     'login --code <code>',
   ].join(' ');
 }
 
+function authorizationChannel(metadata, runtime, pending = null) {
+  return metadata.channel
+    || pending?.channel
+    || channelFromProfile({ api_base: pending?.api_base || runtime.apiBase });
+}
+
 function updateRuntimeFromOAuthProfile(runtime, profile) {
   const oauthApiBase = getOAuthApiBase(profile);
   runtime.jwt = profile.oauth_access_token;
@@ -875,6 +899,7 @@ async function redeemAuthorizationCode(runtime, code, fetchImpl) {
     resource: pending.resource,
     clientId: pending.client_id,
     tokenEndpoint: pending.token_endpoint,
+    channel: pending.channel,
   };
   if (!metadata.issuer || !metadata.resource || !metadata.clientId || !metadata.tokenEndpoint) {
     throw oauthError(
@@ -961,7 +986,10 @@ export async function loginWithOAuth(runtime, options = {}, output, fetchImpl =
             scopes: pendingScopes,
           }),
           expires_in: Math.max(0, Number(pending.expires_at) - Math.floor(Date.now() / 1000)),
-          redeem_command: redeemCommand(runtime.profileName),
+          redeem_command: redeemCommand(
+            runtime.profileName,
+            authorizationChannel(metadata, runtime, pending),
+          ),
         },
       };
     }
@@ -1010,6 +1038,7 @@ export async function loginWithOAuth(runtime, options = {}, output, fetchImpl =
       client_id: metadata.clientId,
       token_endpoint: metadata.tokenEndpoint,
       authorization_endpoint: metadata.authorizationEndpoint,
+      channel: authorizationChannel(metadata, runtime),
       scopes,
       expires_at: Math.floor(Date.now() / 1000) + PENDING_LOGIN_TTL_SECONDS,
     });
@@ -1021,7 +1050,10 @@ export async function loginWithOAuth(runtime, options = {}, output, fetchImpl =
       agentAuthorization: {
         authorize_url: authorizeUrl,
         expires_in: PENDING_LOGIN_TTL_SECONDS,
-        redeem_command: redeemCommand(runtime.profileName),
+        redeem_command: redeemCommand(
+          runtime.profileName,
+          authorizationChannel(metadata, runtime),
+        ),
       },
     };
   }

package/src/runtime/profiles.js

@@ -12,6 +12,7 @@ import { homedir } from 'node:os';
 import { dirname, join, parse, resolve } from 'node:path';
 import { CliError, EXIT_CODES } from './errors.js';
 import { getAuthRecovery, quoteShellArgument } from './auth-recovery.js';
+import { channelFromProfile, cliCommandForChannel, isReleaseChannel } from './channel.js';
 
 export const CONFIG_DIR = join(homedir(), '.notis');
 export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
@@ -95,6 +96,10 @@ function normalizeProfile(rawProfile = {}) {
   return {
     api_base: typeof raw.api_base === 'string' ? raw.api_base : undefined,
     beta: typeof raw.beta === 'boolean' ? raw.beta : undefined,
+    // Which published CLI build this profile runs, as the deployment reported
+    // it at login. Unknown values are dropped rather than trusted: this key
+    // decides which code executes on the next run.
+    channel: isReleaseChannel(raw.channel) ? raw.channel : undefined,
     label: typeof raw.label === 'string' ? raw.label : undefined,
     dev_access_token:
       typeof raw.dev_access_token === 'string' ? raw.dev_access_token : undefined,
@@ -877,7 +882,7 @@ export function resolveRuntimeProfile(
       exitCode: EXIT_CODES.auth,
       hints: [{
         command: [
-          'npx --package @notis_ai/cli@latest -- notis',
+          cliCommandForChannel(channelFromProfile({ api_base: normalizedRequestedApiBase })),
           `--profile ${quoteShellArgument(profileName)}`,
           `--api-base ${quoteShellArgument(normalizedRequestedApiBase)}`,
           'login',
@@ -929,6 +934,17 @@ export function resolveRuntimeProfile(
     profileName,
     profileSource,
     profileLabel: profile.label,
+    // Which published build serves this profile. Carried on the runtime so
+    // every recovery hint prints the command that will actually run.
+    channel: devRuntime
+      ? null
+      : channelFromProfile(
+          (globalOptions.apiBase || process.env.NOTIS_API_BASE)
+            // An explicit route owns this invocation even when the stored
+            // profile is pinned to the opposite release channel.
+            ? { api_base: apiBase }
+            : { ...profile, api_base: apiBase },
+        ),
     apiBase,
     requestedApiBase: normalizedRequestedApiBase,
     jwt,

package/src/runtime/transport.js

@@ -2,6 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { createReadStream } from 'node:fs';
 import { dirname } from 'node:path';
 import { CliError, EXIT_CODES } from './errors.js';
+import { delegatedContextReason } from './delegated-context.js';
 import {
   credentialIsExpired,
   getJwtExpiration,
@@ -327,9 +328,11 @@ export async function httpRequest({
     });
 
     let payload = null;
+    let payloadReadError = null;
     try {
       payload = await response.json();
-    } catch {
+    } catch (error) {
+      payloadReadError = error;
       payload = null;
     }
 
@@ -350,9 +353,11 @@ export async function httpRequest({
           signal: controller.signal,
           ...(requestBody.duplex ? { duplex: requestBody.duplex } : {}),
         });
+        payloadReadError = null;
         try {
           payload = await response.json();
-        } catch {
+        } catch (error) {
+          payloadReadError = error;
           payload = null;
         }
       }
@@ -376,6 +381,14 @@ export async function httpRequest({
       throw normalizeBackendError(response.status, payload, runtime);
     }
 
+    // A successful status is not a successful tool call until its response
+    // body has been read. Mutations may already have committed before a socket
+    // reset truncates the JSON; surface that as an ambiguous network failure
+    // so callers never persist an undefined result or attempt a second write.
+    if (response.status !== 204 && payloadReadError) {
+      throw payloadReadError;
+    }
+
     return {
       requestId,
       payload: payload || {},
@@ -428,6 +441,10 @@ export async function callTool({
       cwd: process.cwd(),
       agent_mode: runtime.agentMode,
       cli_version: runtime.cliVersion,
+      // Reported so the server can refuse work-handing tools from a run Notis
+      // is itself driving. Advisory -- a determined agent can unset the markers
+      // -- so the server treats it as one layer, not the whole guard.
+      ...(delegatedContextReason() ? { delegated_context: true } : {}),
       ...(runtime.debugEntitlementOverride
         ? { debug_entitlement_override: runtime.debugEntitlementOverride }
         : {}),

package/template/.harness/index.html.tmpl

@@ -164,8 +164,35 @@
       });
     });
 
+    /**
+     * Records one runtime call and hands back the entry so the caller can
+     * stamp its outcome once the promise settles. Verify reads `ok` to tell a
+     * route that rendered from real data apart from one that only rendered its
+     * error states, so every runtime path must settle its own entry.
+     */
     function record(op, args) {
-      window.__harness.runtimeCalls.push({ op, args });
+      const entry = { op, args, ok: null, error: null, durationMs: null };
+      entry.startedAt = Date.now();
+      window.__harness.runtimeCalls.push(entry);
+      return entry;
+    }
+
+    function settle(entry, error) {
+      entry.durationMs = Date.now() - entry.startedAt;
+      delete entry.startedAt;
+      entry.ok = !error;
+      entry.error = error ? (error.message ? String(error.message) : String(error)) : null;
+    }
+
+    async function tracked(entry, run) {
+      try {
+        const value = await run();
+        settle(entry, null);
+        return value;
+      } catch (error) {
+        settle(entry, error);
+        throw error;
+      }
     }
 
     async function readJsonOrSnippet(response) {
@@ -214,29 +241,58 @@
         app: descriptor.app,
         route: descriptor.route,
         context: descriptor.context || {},
-        navigate: (args) => record('navigate', args),
+        navigate: (args) => {
+          settle(record('navigate', args), null);
+        },
+        // There is no manager chat here, so the handover is recorded and
+        // reported as drafted without any UI.
+        handover: async (payload) => {
+          settle(record('handover', payload), null);
+          return { status: 'drafted' };
+        },
         registerTopBarSearch: () => {},
         setTopBarSearchValue: () => {},
         setTopBarSearchLoading: () => {},
-        listTools: async () => {
-          record('listTools', {});
-          return descriptor.tools || [];
-        },
-        callTool: async (name, args) => {
-          record('callTool', { name, arguments: args || {} });
-          const fixture = lookupToolFixture(name, args || {});
-          if (fixture !== undefined) {
-            return structuredClone(fixture);
-          }
-          return { ok: true, result: null };
-        },
-        request: async (path, options) => {
-          record('request', { path, options });
-          if (fixtures && fixtures.requests && Object.prototype.hasOwnProperty.call(fixtures.requests, path)) {
-            return structuredClone(fixtures.requests[path]);
-          }
-          return null;
-        },
+        // No change feed here, so `useDatabaseSubscription` reports live=false
+        // and the app keeps whatever manual refresh it offers.
+        subscribeDatabase: () => () => {},
+        // There is no cloud computer behind the harness. Answering "not
+        // available" rather than throwing keeps `useCloudComputer` on the same
+        // fallback branch a user without a cloud computer would see.
+        cloudComputerFacts: async () => tracked(
+          record('cloudComputerFacts', {}),
+          async () => ({
+            available: false,
+            reason: 'unsupported_host',
+            sandbox: null,
+            cli_auth: {
+              gh: { authenticated: null, account: null, checked_at: null, reason: 'unsupported_host' },
+            },
+          }),
+        ),
+        listTools: async () => tracked(
+          record('listTools', {}),
+          async () => descriptor.tools || [],
+        ),
+        callTool: async (name, args) => tracked(
+          record('callTool', { name, arguments: args || {} }),
+          async () => {
+            const fixture = lookupToolFixture(name, args || {});
+            if (fixture !== undefined) {
+              return structuredClone(fixture);
+            }
+            return { ok: true, result: null };
+          },
+        ),
+        request: async (path, options) => tracked(
+          record('request', { path, options }),
+          async () => {
+            if (fixtures && fixtures.requests && Object.prototype.hasOwnProperty.call(fixtures.requests, path)) {
+              return structuredClone(fixtures.requests[path]);
+            }
+            return null;
+          },
+        ),
       };
     }
 
@@ -270,32 +326,45 @@
     function liveRuntime() {
       return {
         ...stubRuntime(),
-        listTools: async () => {
-          record('listTools', {});
-          const result = await runtimeQuery({ method: 'tools/list' });
-          return result.tools || [];
-        },
-        callTool: async (name, args) => {
-          record('callTool', { name, arguments: args || {} });
-          return runtimeQuery({ method: 'tools/call', name, arguments: args || {} });
-        },
-        request: async (path, options) => {
-          record('request', { path, options });
-          const response = await fetch(`${String(apiBase).replace(/\/$/, '')}${path}`, {
-            method: (options && options.method) || 'GET',
-            headers: {
-              Authorization: `Bearer ${jwt}`,
-              ...((options && options.body) ? { 'Content-Type': 'application/json' } : {}),
-              ...((options && options.headers) || {}),
-            },
-            body: options && options.body ? JSON.stringify(options.body) : undefined,
-          });
-          const { payload, snippet } = await readJsonOrSnippet(response);
-          if (!response.ok) {
-            throw new Error((payload && (payload.error || payload.message)) || snippet || `Request failed with status ${response.status}`);
-          }
-          return payload;
-        },
+        listTools: async () => tracked(
+          record('listTools', {}),
+          async () => {
+            const result = await runtimeQuery({ method: 'tools/list' });
+            return result.tools || [];
+          },
+        ),
+        callTool: async (name, args) => tracked(
+          record('callTool', { name, arguments: args || {} }),
+          async () => runtimeQuery({ method: 'tools/call', name, arguments: args || {} }),
+        ),
+        // Live mode must not inherit the stub's canned answer: it would settle
+        // ok: true with fake data and soften the all-calls-failed assertion.
+        cloudComputerFacts: async (options) => tracked(
+          record('cloudComputerFacts', options || {}),
+          async () => runtimeQuery({
+            method: 'cloud_computer/facts',
+            ...(options && options.refresh ? { refresh: true } : {}),
+          }),
+        ),
+        request: async (path, options) => tracked(
+          record('request', { path, options }),
+          async () => {
+            const response = await fetch(`${String(apiBase).replace(/\/$/, '')}${path}`, {
+              method: (options && options.method) || 'GET',
+              headers: {
+                Authorization: `Bearer ${jwt}`,
+                ...((options && options.body) ? { 'Content-Type': 'application/json' } : {}),
+                ...((options && options.headers) || {}),
+              },
+              body: options && options.body ? JSON.stringify(options.body) : undefined,
+            });
+            const { payload, snippet } = await readJsonOrSnippet(response);
+            if (!response.ok) {
+              throw new Error((payload && (payload.error || payload.message)) || snippet || `Request failed with status ${response.status}`);
+            }
+            return payload;
+          },
+        ),
       };
     }