@oar-sh/oar 0.9.6 → 0.9.8

package/server/services/git-remote-service.mjs

@@ -0,0 +1,115 @@
+'use strict';
+
+import { execFile as nodeExecFile } from 'child_process';
+
+import { normalizeGitHubRepoUrl } from '../../shared/claude-cloud/repo-url.mjs';
+import { createGitChangesService } from './git-changes-service.mjs';
+
+// What a folder's git checkout says about where it lives on GitHub: the
+// remote, the branch, and how far the checkout is from what was pushed. The
+// New Chat modal fills the repository and branch of a Claude Cloud chat from
+// it and warns about work the cloud clone will not have (commits that were
+// never pushed, uncommitted changes).
+//
+// Read-only: `git status` and `git remote get-url`, nothing else. The route
+// validates the folder before calling in.
+
+const GIT_COMMAND_TIMEOUT_MS = 15_000;
+const DEFAULT_REMOTE = 'origin';
+
+const NO_GIT = Object.freeze({
+  hasGit: false,
+  remoteUrl: null,
+  repoUrl: null,
+  slug: null,
+  branch: null,
+  upstream: null,
+  ahead: 0,
+  behind: 0,
+  dirty: false,
+});
+
+/**
+ * A remote URL as the browser may see it: credentials in front of the host
+ * (`https://user:secret@host/…`) are dropped. The scp form keeps its `git@`.
+ */
+export function redactRemoteUrlCredentials(remoteUrl) {
+  const text = String(remoteUrl || '').trim();
+  if (!text) return '';
+  if (!/^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(text)) return text;
+  try {
+    const url = new URL(text);
+    if (!url.username && !url.password) return text;
+    // ssh://git@host/… names the transport user, not a secret.
+    if (url.protocol === 'ssh:' && !url.password) return text;
+    url.username = '';
+    url.password = '';
+    return url.toString();
+  } catch {
+    return text.replace(/\/\/[^/@\s]*@/, '//');
+  }
+}
+
+/** The remote a tracking ref such as `fork/main` lives on, or ''. */
+function remoteOfUpstream(upstream) {
+  const text = String(upstream || '').trim();
+  const slash = text.indexOf('/');
+  return slash > 0 ? text.slice(0, slash) : '';
+}
+
+export function createGitRemoteService({
+  execFileImpl = nodeExecFile,
+  gitChangesService = createGitChangesService({ execFileImpl }),
+} = {}) {
+  function readRemoteUrl(rootPath, remoteName) {
+    return new Promise((resolve) => {
+      try {
+        execFileImpl('git', ['remote', 'get-url', remoteName], {
+          cwd: rootPath,
+          timeout: GIT_COMMAND_TIMEOUT_MS,
+          windowsHide: true,
+        }, (error, stdout) => {
+          // No such remote is an answer, not a failure.
+          resolve(error ? '' : String(stdout || '').trim().split(/\r?\n/)[0] || '');
+        });
+      } catch {
+        resolve('');
+      }
+    });
+  }
+
+  /**
+   * `{ ok, hasGit, remoteUrl, repoUrl, slug, branch, upstream, ahead, behind,
+   * dirty }` for a folder; `hasGit: false` when it is not a git checkout.
+   */
+  async function describe(rootPath) {
+    const status = await gitChangesService.getStatus(rootPath);
+    if (!status?.ok) return { ok: false, error: status?.error || 'Failed to read git status' };
+    if (status.isRepo === false) return { ok: true, ...NO_GIT };
+
+    const upstream = String(status.upstream || '').trim();
+    let remoteUrl = await readRemoteUrl(rootPath, DEFAULT_REMOTE);
+    const upstreamRemote = remoteOfUpstream(upstream);
+    if (!remoteUrl && upstreamRemote && upstreamRemote !== DEFAULT_REMOTE) {
+      remoteUrl = await readRemoteUrl(rootPath, upstreamRemote);
+    }
+    // One validator for the modal and for the bootstrap that follows it: a
+    // remote the bootstrap would refuse is shown as "no GitHub remote".
+    const repo = normalizeGitHubRepoUrl(remoteUrl);
+    const branch = status.detached ? '' : String(status.branch || '').trim();
+    return {
+      ok: true,
+      hasGit: true,
+      remoteUrl: redactRemoteUrlCredentials(remoteUrl) || null,
+      repoUrl: repo?.repoUrl || null,
+      slug: repo?.slug || null,
+      branch: branch || null,
+      upstream: upstream || null,
+      ahead: Number(status.ahead || 0),
+      behind: Number(status.behind || 0),
+      dirty: Array.isArray(status.files) && status.files.length > 0,
+    };
+  }
+
+  return { describe };
+}

package/server/services/oar-cli-helpers.mjs

@@ -4,6 +4,7 @@
  */
 
 import { randomBytes } from 'node:crypto';
+import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 
@@ -45,7 +46,7 @@ export function relayUrl({ config, lanAddress = null } = {}) {
  * the service runs server.js directly with the same env the launcher would set,
  * so a `gh copilot` session is not tied to the unit's lifetime.
  */
-export function buildSystemdUnit({ nodeBin, packageRoot, configPath, dataDir, logDir }) {
+export function buildSystemdUnit({ nodeBin, packageRoot, configPath, dataDir, logDir, pathEnv = '' }) {
   // systemd units are Linux-only, so the path inside the unit is always
   // posix-joined — host-platform path.join would write backslashes when this
   // template is exercised on Windows (tests; the CLI never writes it there).
@@ -59,6 +60,10 @@ export function buildSystemdUnit({ nodeBin, packageRoot, configPath, dataDir, lo
     `Environment=COPILOT_WEB_RELAY_CONFIG=${configPath}`,
     `Environment=COPILOT_WEB_RELAY_DATA_DIR=${dataDir}`,
     `Environment=COPILOT_WEB_RELAY_LOG_DIR=${logDir}`,
+    // A user service starts with systemd's bare PATH: without this line the
+    // relay's sessions find neither the provider CLIs in ~/.local/bin nor, on
+    // an install with a private Node, `node` and `npm` themselves.
+    ...(pathEnv ? [`Environment="PATH=${escapeSystemdValue(pathEnv)}"`] : []),
     'Restart=on-failure',
     'RestartSec=5',
     '',
@@ -68,6 +73,67 @@ export function buildSystemdUnit({ nodeBin, packageRoot, configPath, dataDir, lo
   ].join('\n');
 }
 
+// Inside a quoted systemd assignment a backslash and a quote need escaping,
+// and `%` opens a specifier.
+function escapeSystemdValue(value) {
+  return String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%');
+}
+
+/**
+ * The PATH a relay service gets: the PATH `oar setup` ran with (the user's
+ * shell, so their tools), with two directories added when they are not on it:
+ * `~/.local/bin`, where the provider CLIs install themselves and which a
+ * shell only picks up once it exists, and the directory of the Node that runs
+ * the relay.
+ */
+export function buildServicePath({ nodeBin, envPath = '', homeDir = '' } = {}) {
+  const entries = String(envPath || '').split(':').filter(Boolean);
+  const localBin = homeDir ? path.posix.join(String(homeDir), '.local', 'bin') : '';
+  if (localBin && !entries.includes(localBin)) entries.unshift(localBin);
+  const nodeDir = nodeBin ? path.posix.dirname(String(nodeBin)) : '';
+  if (nodeDir && !entries.includes(nodeDir)) entries.push(nodeDir);
+  return entries.join(':');
+}
+
+/**
+ * The dependencies whose install scripts OAR needs (they fetch or build a
+ * native binary). npm 12 runs no install script it was not told to allow, and
+ * a global install has no package.json of its own to say so; npm 10 and 11
+ * accept the flag and run the scripts as before. `npm-install-scripts.test.mjs`
+ * holds this list to the lockfile.
+ */
+export const NPM_INSTALL_SCRIPT_PACKAGES = Object.freeze(['better-sqlite3', 'cloudflared', 'koffi']);
+export const NPM_ALLOW_SCRIPTS_ARG = `--allow-scripts=${NPM_INSTALL_SCRIPT_PACKAGES.join(',')}`;
+
+/**
+ * How to run `npm install -g` so the update lands in the install that is
+ * running. Away from Windows: the npm that belongs to this Node (a relay
+ * service or a private Node has no `npm` on PATH, and a version manager may
+ * put another Node's there), this Node first on the child's PATH because npm
+ * is a `node` script, and the prefix this package sits in, so an install made
+ * with `--prefix` is updated in place.
+ */
+export function resolveNpmInvocation({
+  execPath = process.execPath,
+  packageRoot = '',
+  platform = process.platform,
+  env = process.env,
+  existsImpl = fs.existsSync,
+} = {}) {
+  if (platform === 'win32') return { command: 'npm.cmd', prefixArgs: [], env: { ...env } };
+  const nodeDir = path.posix.dirname(String(execPath || ''));
+  const beside = path.posix.join(nodeDir, 'npm');
+  const command = nodeDir && existsImpl(beside) ? beside : 'npm';
+  const envPath = String(env?.PATH || '');
+  const childPath = envPath.split(':')[0] === nodeDir ? envPath : [nodeDir, envPath].filter(Boolean).join(':');
+  const suffix = '/lib/node_modules/@oar-sh/oar';
+  const root = String(packageRoot || '').replace(/\/+$/, '');
+  const prefixArgs = root.endsWith(suffix) && root.length > suffix.length
+    ? ['--prefix', root.slice(0, -suffix.length)]
+    : [];
+  return { command, prefixArgs, env: { ...env, PATH: childPath } };
+}
+
 /**
  * Provider CLIs `oar doctor` probes, with the args that answer fast. Cursor is
  * deliberately absent: the relay drives it through the bundled @cursor/sdk npm

package/server/services/plan-usage-claude-cloud.mjs

@@ -0,0 +1,211 @@
+'use strict';
+
+/**
+ * Claude Cloud usage (provider `claude-cloud`).
+ *
+ * Cloud sessions are billed to the Claude account: a dollar credit is spent
+ * first where the account holds one, and without it the turns count against
+ * the same 5-hour and weekly windows the Claude card shows. So this card has
+ * no windows of its own. It shows
+ *  - the dollar buckets of the live account usage (the credit and its expiry),
+ *  - what the relay's own cloud conversations have cost, as Anthropic reported
+ *    it per session (the relay keeps the latest figure per conversation; there
+ *    is no account-wide total to ask for),
+ *  - the session detail of the latest cloud worker report.
+ *
+ * The credit arrives under an internal codename that may change, so every
+ * top-level bucket of the usage body that carries a dollar limit is a meter;
+ * the codename table only supplies a nicer label.
+ */
+
+import {
+  SOURCE_LIVE,
+  SOURCE_WORKER,
+  STATUS_OK,
+  STATUS_PARTIAL,
+  STATUS_UNAVAILABLE,
+  buildDetailSection,
+  buildMeter,
+  buildProviderCard,
+  pickNonNegative,
+  toFiniteNumber,
+  toIsoTimestamp,
+  toTrimmedString,
+} from './plan-usage-contract.mjs';
+import { CLAUDE_USAGE_URL, buildClaudeSessionSections, formatClaudeMoney } from './plan-usage-claude.mjs';
+
+export const CLAUDE_CLOUD_PROVIDER_ID = 'claude-cloud';
+export const CLAUDE_CLOUD_LABEL = 'Claude Cloud';
+
+const CLAUDE_CODE_WEB_URL = 'https://claude.ai/code';
+
+// Null-prototype: the keys come from an API body.
+const DOLLAR_BUCKET_LABELS = Object.freeze(Object.assign(Object.create(null), {
+  iguana_necktie: 'Cloud sessions credit',
+}));
+
+/** "maple_sprocket" → "Maple sprocket credit": the label of a bucket the table does not know. */
+export function humanizeDollarBucketKey(key) {
+  const words = String(key ?? '').replace(/[^A-Za-z0-9]+/g, ' ').trim().toLowerCase();
+  if (!words) return 'Credit';
+  return `${words.charAt(0).toUpperCase()}${words.slice(1)} credit`;
+}
+
+/**
+ * The dollar buckets of an account usage body, in the body's order: every
+ * top-level value that is an object with a numeric `limit_dollars`.
+ */
+export function listClaudeDollarBuckets(usageBody) {
+  if (!usageBody || typeof usageBody !== 'object' || Array.isArray(usageBody)) return [];
+  const buckets = [];
+  for (const [key, value] of Object.entries(usageBody)) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) continue;
+    const limitUsd = toFiniteNumber(value.limit_dollars);
+    if (limitUsd === null) continue;
+    buckets.push({
+      key,
+      label: DOLLAR_BUCKET_LABELS[key] || humanizeDollarBucketKey(key),
+      limitUsd,
+      usedUsd: toFiniteNumber(value.used_dollars),
+      remainingUsd: toFiniteNumber(value.remaining_dollars),
+      utilization: toFiniteNumber(value.utilization),
+      expiresAt: toIsoTimestamp(value.resets_at),
+    });
+  }
+  return buckets;
+}
+
+/**
+ * What the credit-offer answer says: `{ open, amount }`, where `amount` is
+ * the formatted sum when the answer names one. An offer that was granted
+ * already is not open.
+ */
+export function describeClaudeCreditOffer(offer) {
+  if (!offer || typeof offer !== 'object') return { open: false, amount: null };
+  const open = (offer.available === true || offer.eligible === true) && offer.granted !== true;
+  const minor = toFiniteNumber(offer.amount_minor_units);
+  const amount = minor !== null && minor > 0 ? formatClaudeMoney(minor / 100, offer.currency) : null;
+  return { open, amount };
+}
+
+/**
+ * @param {object} options
+ * @param {object|null} options.account  live account usage (`{ usage, prepaid,
+ *   offer, fetchedAt, error }`), or null when it was not read
+ * @param {object|null} options.spend    what the relay recorded: `{ totalUsd,
+ *   conversationCount, conversation: { costUsd } | null }` (`conversation` is
+ *   the one the modal was opened from, when it is a cloud conversation)
+ * @param {object|null} options.usage    the latest `claude-cloud` snapshot
+ * @param {string|null} options.capturedAt  when that snapshot was stored
+ * @param {boolean} options.configured   Claude Cloud provider enabled
+ */
+export function buildClaudeCloudPlanCard({
+  account = null,
+  spend = null,
+  usage = null,
+  capturedAt = null,
+  configured = true,
+} = {}) {
+  // Opt-in like Grok: no card at all while the provider is off.
+  if (!configured) return null;
+
+  const hasAccount = !!account?.usage && typeof account.usage === 'object';
+  const buckets = hasAccount ? listClaudeDollarBuckets(account.usage) : [];
+  const meters = buckets.map((bucket) => buildMeter({
+    id: `claude-cloud-credit-${bucket.key.replace(/[^A-Za-z0-9_]+/g, '-')}`,
+    label: bucket.label,
+    unit: 'usd',
+    used: bucket.usedUsd,
+    allowance: bucket.limitUsd,
+    remaining: bucket.remainingUsd,
+    // The dollars are exact; the percentage only stands in when they are missing.
+    utilization: bucket.usedUsd === null && bucket.remainingUsd === null ? bucket.utilization : null,
+    resetAt: bucket.expiresAt,
+    resetKind: 'expiry',
+    emphasis: 'primary',
+  })).filter(Boolean);
+  const hasCredit = meters.length > 0;
+
+  const details = [];
+  const conversationCount = Math.max(0, Math.round(toFiniteNumber(spend?.conversationCount) || 0));
+  if (conversationCount > 0) {
+    const totalUsd = pickNonNegative(spend?.totalUsd) ?? 0;
+    const countText = `${conversationCount} cloud conversation${conversationCount === 1 ? '' : 's'}`;
+    meters.push(buildMeter({
+      id: 'claude-cloud-spend',
+      label: 'Cloud spend (OAR sessions)',
+      unit: 'usd',
+      used: totalUsd,
+      emphasis: hasCredit ? 'secondary' : 'primary',
+      note: `${countText} on this relay. Anthropic’s reported cost, not a billing statement.`,
+    }));
+    const rows = [{ label: 'All cloud conversations', value: formatClaudeMoney(totalUsd), hint: countText }];
+    if (spend?.conversation && typeof spend.conversation === 'object') {
+      const cost = pickNonNegative(spend.conversation.costUsd);
+      rows.push({
+        label: 'This conversation',
+        value: cost === null ? '—' : formatClaudeMoney(cost),
+        hint: cost === null ? 'No cost reported yet' : null,
+      });
+    }
+    details.push(buildDetailSection({
+      id: 'claude-cloud-spend',
+      label: 'Cloud spend (OAR sessions)',
+      note: 'The cost Anthropic reports per cloud session, summed over the cloud conversations this relay still has. Not a billing statement; sessions started elsewhere are not included.',
+      rows,
+    }));
+  }
+
+  details.push(...buildClaudeSessionSections(usage?.session, {
+    idPrefix: 'claude-cloud',
+    sessionLabel: 'Latest cloud session report',
+    modelsLabel: 'By model (latest cloud session report)',
+    costLabel: 'Reported cost',
+    costHint: 'Anthropic’s reported cost, not a billing statement',
+  }));
+
+  const notes = [];
+  const offer = describeClaudeCreditOffer(account?.offer);
+  if (!hasCredit && offer.open) {
+    notes.push({
+      id: 'claude-cloud-credit-offer',
+      text: offer.amount
+        ? `A cloud credit of ${offer.amount} is available to claim on claude.ai.`
+        : 'A cloud credit is available to claim on claude.ai.',
+      link: { label: 'Open the usage page', url: CLAUDE_USAGE_URL },
+    });
+  }
+  notes.push({
+    id: 'claude-cloud-billing',
+    text: 'Cloud turns spend the cloud credit first; without a credit they count against the Claude limits (5-hour and weekly).',
+  });
+
+  const resolvedMeters = meters.filter(Boolean);
+  const resolvedDetails = details.filter(Boolean);
+  let status = STATUS_OK;
+  let message = null;
+  if (!hasAccount) {
+    status = resolvedMeters.length || resolvedDetails.length ? STATUS_PARTIAL : STATUS_UNAVAILABLE;
+    message = ['The account usage could not be read, so a cloud credit is not shown.', toTrimmedString(account?.error)]
+      .filter(Boolean)
+      .join(' ');
+  } else if (!resolvedMeters.length) {
+    message = 'This account holds no cloud credit, and no cloud conversation on this relay has run yet.';
+  }
+
+  return buildProviderCard({
+    provider: CLAUDE_CLOUD_PROVIDER_ID,
+    label: CLAUDE_CLOUD_LABEL,
+    status,
+    message,
+    source: hasAccount ? SOURCE_LIVE : SOURCE_WORKER,
+    capturedAt: hasAccount ? (toIsoTimestamp(account.fetchedAt) || capturedAt) : capturedAt,
+    meters: resolvedMeters,
+    details: resolvedDetails,
+    notes,
+    links: [
+      { label: 'Claude usage settings', url: CLAUDE_USAGE_URL },
+      { label: 'Claude Code on the web', url: CLAUDE_CODE_WEB_URL },
+    ],
+  });
+}