@oar-sh/oar 0.9.0

package/.github/extensions/web-relay/skills/tool-activity.mjs

@@ -0,0 +1,243 @@
+import {
+  formatStoreMemoryActivity,
+  formatToolResultActivity as formatSharedToolResultActivity,
+  formatVoteMemoryActivity,
+} from "../../../../shared/tool-activity.mjs";
+
+export function normalizeActivityText(value, maxToolDetailLength = 140) {
+  const text = String(value || "").trim();
+  if (!text) return "";
+  return text.replace(/\s+/g, " ").slice(0, maxToolDetailLength);
+}
+
+export function parseMaybeJson(value) {
+  if (typeof value !== "string") return value;
+  const text = value.trim();
+  if (!text || (!text.startsWith("{") && !text.startsWith("["))) return value;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return value;
+  }
+}
+
+export function parsedQuestionSources(request) {
+  const parsedToolArgs = parseMaybeJson(request?.toolArgs);
+  const parsedInput = parseMaybeJson(request?.input);
+  const parsedArguments = parseMaybeJson(request?.arguments);
+  const parsedArgs = parseMaybeJson(request?.args);
+  const parsedBody = parseMaybeJson(request?.body);
+  const parsedRequest = parseMaybeJson(request?.request);
+  return [
+    request,
+    parsedToolArgs,
+    parsedInput,
+    parsedArguments,
+    parsedArgs,
+    parsedBody,
+    parsedRequest,
+    parsedBody?.input,
+    parsedBody?.arguments,
+    parsedRequest?.input,
+    parsedRequest?.arguments,
+  ].filter(Boolean);
+}
+
+export function toolArgsSnapshot(request) {
+  const candidates = [
+    request?.toolArgs,
+    request?.arguments,
+    request?.args,
+    request?.input,
+    request?.payload,
+    request?.toolInput,
+    request?.toolCall?.arguments,
+    request?.toolCall?.input,
+  ];
+  for (const value of candidates) {
+    const parsed = parseMaybeJson(value);
+    if (parsed && typeof parsed === "object") return parsed;
+  }
+  return {};
+}
+
+export function extractToolName(request) {
+  const candidates = [
+    request?.toolName,
+    request?.name,
+    request?.tool?.name,
+    request?.tool?.id,
+    request?.toolCall?.name,
+    request?.toolCall?.toolName,
+  ];
+
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+export function extractToolDetail(request, maxToolDetailLength = 140) {
+  const args = toolArgsSnapshot(request);
+  const name = extractToolName(request).toLowerCase();
+  const candidateText = normalizeActivityText(
+    args.question ||
+    args.prompt ||
+    args.description ||
+    args.intent ||
+    args.pattern ||
+    args.path ||
+    args.query ||
+    args.url ||
+    args.command ||
+    "",
+    maxToolDetailLength,
+  );
+
+  if (name.includes("ask_user") && candidateText) return `question=\"${candidateText}\"`;
+  if ((name.includes("glob") || name.includes("rg") || name.includes("grep")) && candidateText) return `query=\"${candidateText}\"`;
+  if (name.includes("powershell") && candidateText) return `command=\"${candidateText}\"`;
+  if (candidateText) return candidateText;
+  return "";
+}
+
+export function formatToolActivity(request, maxToolDetailLength = 140) {
+  const rawName = extractToolName(request);
+  if (!rawName) return null;
+
+  const lower = rawName.toLowerCase();
+  const detail = extractToolDetail(request, maxToolDetailLength);
+
+  if (lower.includes("store_memory")) {
+    return formatStoreMemoryActivity(rawName, toolArgsSnapshot(request));
+  }
+  if (lower.includes("vote_memory")) {
+    return formatVoteMemoryActivity(rawName, toolArgsSnapshot(request));
+  }
+
+  if (lower.includes("search (glob)") || /(^|[.\s_-])glob($|[.\s_-])/.test(lower)) {
+    return detail ? `Search (glob): ${detail}` : "Search (glob)";
+  }
+  if (lower.includes("search (grep)") || /(^|[.\s_-])(rg|grep)($|[.\s_-])/.test(lower)) {
+    return detail ? `Search (grep): ${detail}` : "Search (grep)";
+  }
+  if (lower.includes("web_search") || lower.includes("web search")) {
+    return detail ? `Web Search: ${detail}` : "Web Search";
+  }
+  if (lower.includes("web_fetch") || lower.includes("web fetch")) {
+    return detail ? `Web Fetch: ${detail}` : "Web Fetch";
+  }
+  if (lower.includes("ask_user")) {
+    return detail ? `Tool (ask_user): ${detail}` : "Tool (ask_user)";
+  }
+  if (lower.includes("report_intent")) {
+    return detail ? `● ${detail}` : "● Working…";
+  }
+  return detail ? `Tool (${rawName}): ${detail}` : `Tool (${rawName})`;
+}
+
+export function formatToolResultActivity(request, result, maxToolDetailLength = 140) {
+  return formatSharedToolResultActivity(extractToolName(request), result, maxToolDetailLength);
+}
+
+export function isAskUserTool(request) {
+  return extractToolName(request).toLowerCase().includes("ask_user");
+}
+
+export function extractQuestionPrompt(request) {
+  const candidates = [];
+  for (const source of parsedQuestionSources(request)) {
+    candidates.push(
+      source?.prompt,
+      source?.text,
+      source?.message,
+      source?.question,
+      source?.content,
+      source?.instruction,
+    );
+  }
+
+  for (const value of candidates) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+
+  if (request && typeof request === "object") {
+    const keys = Object.keys(request).slice(0, 8);
+    if (keys.length) {
+      return `Clarification needed (${keys.join(", ")})`;
+    }
+  }
+
+  return "Clarification needed";
+}
+
+export function extractQuestionChoices(request) {
+  const rawCandidates = [];
+  for (const source of parsedQuestionSources(request)) {
+    rawCandidates.push(
+      source?.choices,
+      source?.options,
+      source?.items,
+      source?.suggestions,
+    );
+    // Also check JSON Schema format: requestedSchema.properties.*.oneOf or enum
+    const schema = source?.requestedSchema;
+    if (schema?.properties) {
+      for (const prop of Object.values(schema.properties)) {
+        if (Array.isArray(prop?.oneOf)) {
+          rawCandidates.push(prop.oneOf);
+        }
+        if (Array.isArray(prop?.enum)) {
+          rawCandidates.push(prop.enum);
+        }
+      }
+    }
+  }
+
+  const raw = rawCandidates.find((value) => Array.isArray(value)) || [];
+  if (!Array.isArray(raw)) return [];
+  return raw
+    .map((choice) => {
+      if (typeof choice === "string") return choice.trim();
+      if (choice && typeof choice === "object") {
+        // Support JSON Schema oneOf format: {const: "value", title: "Display Label"}
+        return String(choice.title || choice.label || choice.text || choice.value || choice.const || "").trim();
+      }
+      return "";
+    })
+    .filter(Boolean)
+    .slice(0, 8);
+}
+
+export function buildAskUserQuestionRequest(request) {
+  const args = toolArgsSnapshot(request);
+  return {
+    prompt:
+      args?.question ||
+      args?.prompt ||
+      args?.message ||
+      request?.question ||
+      request?.prompt ||
+      "Clarification needed",
+    choices: extractQuestionChoices({ ...request, ...args }),
+    allow_freeform: args?.allow_freeform,
+    request,
+  };
+}
+
+export function serializeRequest(request) {
+  if (!request || typeof request !== "object") return null;
+  const seen = new WeakSet();
+  try {
+    return JSON.stringify(request, (key, value) => {
+      if (typeof value === "function") return `[Function ${value.name || "anonymous"}]`;
+      if (typeof value === "object" && value !== null) {
+        if (seen.has(value)) return "[Circular]";
+        seen.add(value);
+      }
+      return value;
+    });
+  } catch {
+    return null;
+  }
+}

package/.github/extensions/web-relay/utils/process-utils.mjs

@@ -0,0 +1,25 @@
+export function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function killProcessTree(proc) {
+  if (!proc || proc.exitCode !== null) return;
+
+  const isWindows = process.platform === "win32";
+  const pidTarget = (!isWindows && proc.spawnargs) ? -proc.pid : proc.pid;
+
+  try {
+    process.kill(pidTarget, "SIGTERM");
+  } catch {
+    return;
+  }
+
+  setTimeout(() => {
+    if (proc.exitCode !== null) return;
+    try { process.kill(pidTarget, "SIGKILL"); } catch {}
+  }, 1200);
+}

package/.github/extensions/web-relay/utils/token-generation.mjs

@@ -0,0 +1,58 @@
+import { randomBytes } from "crypto";
+
+const TOKEN_FALLBACK_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+function randomInt(maxExclusive) {
+  if (!Number.isInteger(maxExclusive) || maxExclusive <= 0) {
+    throw new Error("randomInt maxExclusive must be a positive integer");
+  }
+  const threshold = Math.floor(256 / maxExclusive) * maxExclusive;
+  while (true) {
+    const value = randomBytes(1)[0];
+    if (value < threshold) return value % maxExclusive;
+  }
+}
+
+function generateRandomToken(length, alphabet) {
+  if (!Number.isInteger(length) || length <= 0 || length > alphabet.length) {
+    throw new Error("Token length must be a positive integer up to alphabet size");
+  }
+  const pool = alphabet.split("");
+  let token = "";
+  for (let i = 0; i < length; i += 1) {
+    const idx = randomInt(pool.length);
+    token += pool[idx];
+    pool.splice(idx, 1);
+  }
+  return token;
+}
+
+function normalizedEntropy(value) {
+  const token = String(value || "");
+  if (!token.length) return 0;
+  const counts = new Map();
+  for (const ch of token) {
+    counts.set(ch, (counts.get(ch) || 0) + 1);
+  }
+  const unique = counts.size;
+  if (unique <= 1) return 0;
+  let entropy = 0;
+  for (const count of counts.values()) {
+    const p = count / token.length;
+    entropy -= p * Math.log2(p);
+  }
+  const maxEntropy = Math.log2(unique);
+  return maxEntropy > 0 ? entropy / maxEntropy : 0;
+}
+
+export function generateHighEntropyToken({
+  length = 16,
+  minEntropy = 0.95,
+  alphabet = TOKEN_FALLBACK_ALPHABET,
+} = {}) {
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    const token = generateRandomToken(length, alphabet);
+    if (normalizedEntropy(token) >= minEntropy) return token;
+  }
+  throw new Error(`Could not generate fallback token with normalized entropy >= ${minEntropy}`);
+}

package/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to OAR are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow semver.
+
+## [0.9.0] — 2026-09-02
+
+### Changed
+
+- **The project is now OAR — Open Agent Relay** (`@oar-sh/oar`, binary `oar`,
+  home at [oar.sh](https://oar.sh)). It began life as `copilot-remote` and has
+  long outgrown the name: one relay now drives Copilot (CLI extension or SDK
+  engine), Claude (Agent SDK), Cursor, Grok, and OpenAI BYOK.
+- Global installs keep their state in `~/.oar` (`%APPDATA%\oar` on Windows) so
+  `npm i -g` updates can never touch the database. Existing state from a git
+  checkout or the legacy managed config dir is migrated in once, copy-never-move,
+  with WAL checkpointing and integrity verification; the old tree is left behind
+  as the rollback path. Git checkouts keep their repo-local layout unchanged.
+- The published npm package now contains only the runtime (an explicit `files`
+  allowlist); tests, docs, and screenshots stay in the repo.
+
+### Added
+
+- `oar --migrate-from <old-checkout>` imports relay state from a pre-rename
+  checkout into `~/.oar`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Simon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.