opencode-agentrouter-auth 0.0.0-stage → 0.1.6

package/local-checkin.mjs

@@ -0,0 +1,270 @@
+#!/usr/bin/env node
+import * as fs from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { fileURLToPath } from "node:url";
+import { randomUUID } from "node:crypto";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { setTimeout as sleep } from "node:timers/promises";
+
+const DAY = 24 * 60 * 60 * 1000;
+const REPO = path.dirname(fileURLToPath(import.meta.url));
+const RESULTS = new Set(["claimed", "done", "failed", "ineligible"]);
+class LocalError extends Error {
+  constructor(code) { super(code); this.code = code; }
+}
+const fail = (code) => { throw new LocalError(code); };
+const inside = (parent, child) => {
+  const relative = path.relative(parent, child);
+  return relative === "" || (!relative.startsWith(".." + path.sep) && relative !== ".." && !path.isAbsolute(relative));
+};
+
+export function defaultHome() {
+  return process.platform === "win32"
+    ? path.join(process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local"), "AgentRouterCheckin")
+    : path.join(os.homedir(), ".local", "share", "agentrouter-checkin");
+}
+
+async function outsideGit(directory) {
+  for (let current = directory; ; current = path.dirname(current)) {
+    try { await fs.lstat(path.join(current, ".git")); fail("UNSAFE_HOME"); }
+    catch (error) { if (error.code !== "ENOENT") throw error; }
+    if (current === path.dirname(current)) return;
+  }
+}
+
+async function windowsPermissions(home, initialize) {
+  const system = path.join(process.env.SystemRoot || "C:/Windows", "System32");
+  const exec = promisify(execFile);
+  const options = { timeout: 15000, windowsHide: true, maxBuffer: 64 * 1024 };
+  let temporary;
+  try {
+    const identity = await exec(path.join(system, "whoami.exe"), ["/user", "/fo", "csv", "/nh"], options);
+    const sid = identity.stdout.match(/S-1-5-(?:[0-9]+-)*[0-9]+/)?.[0];
+    if (!sid) fail("UNSAFE_WINDOWS_PERMISSIONS");
+    const icacls = path.join(system, "icacls.exe");
+    if (initialize) {
+      await exec(icacls, [home, "/grant:r", "*" + sid + ":(OI)(CI)F", "*S-1-5-18:(OI)(CI)F", "*S-1-5-32-544:(OI)(CI)F", "/inheritance:r"], options);
+    }
+    // Native signed Windows utilities only; no execution-policy bypass or scripts.
+    // /save exports security descriptors, never file contents or credentials.
+    temporary = await fs.mkdtemp(path.join(os.tmpdir(), "ar-acl-"));
+    const saved = path.join(temporary, "permissions.txt");
+    const targets = [home];
+    for (const name of ["config.json", "github-cookie.txt", "state.json"]) {
+      const file = path.join(home, name);
+      try { await fs.lstat(file); targets.push(file); }
+      catch (error) { if (error.code !== "ENOENT") throw error; }
+    }
+    for (const target of targets) {
+      await fs.rm(saved, { force: true });
+      await exec(icacls, [target, "/save", saved], options);
+      const descriptor = (await fs.readFile(saved, "utf16le")).split(/\r?\n/).find(line => line.startsWith("D:"));
+      if (!descriptor) fail("UNSAFE_WINDOWS_PERMISSIONS");
+      let currentUserAllowed = false;
+      for (const match of descriptor.matchAll(/\(([^()]*)\)/g)) {
+        const [type, flags, rights, object, inherited, identity] = match[1].split(";");
+        if (type === "D") continue;
+        if (type !== "A" || object || inherited || ![sid, "BA", "SY", "S-1-5-18", "S-1-5-32-544"].includes(identity)) fail("UNSAFE_WINDOWS_PERMISSIONS");
+        if (identity === sid && rights === "FA" && !flags.includes("IO")) currentUserAllowed = true;
+      }
+      if (!currentUserAllowed) fail("UNSAFE_WINDOWS_PERMISSIONS");
+    }
+  } catch { fail("UNSAFE_WINDOWS_PERMISSIONS"); }
+  finally { if (temporary) await fs.rm(temporary, { recursive: true, force: true }); }
+}
+
+async function homePath(home, create = false) {
+  const resolved = path.resolve(home);
+  if (inside(REPO, resolved) || resolved === path.parse(resolved).root) fail("UNSAFE_HOME");
+  await outsideGit(resolved);
+  if (create) await fs.mkdir(resolved, { recursive: true, mode: 0o700 });
+  const stat = await fs.lstat(resolved);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) fail("UNSAFE_HOME");
+  const canonical = await fs.realpath(resolved);
+  if (inside(await fs.realpath(REPO), canonical)) fail("UNSAFE_HOME");
+  await outsideGit(canonical); // Also checks a repository reached through a parent junction.
+  if (process.platform === "win32") await windowsPermissions(canonical, create);
+  else if (stat.mode & 0o077) fail("UNSAFE_HOME_PERMISSIONS");
+  return canonical;
+}
+
+async function readLocal(file, optional = false) {
+  let info;
+  try { info = await fs.lstat(file); }
+  catch (error) { if (optional && error.code === "ENOENT") return undefined; throw error; }
+  if (!info.isFile() || info.isSymbolicLink() || info.nlink !== 1) fail("UNSAFE_FILE");
+  const handle = await fs.open(file, constants.O_RDONLY | (constants.O_NOFOLLOW || 0));
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > 128 * 1024) fail("INVALID_FILE");
+    return await handle.readFile("utf8");
+  } finally { await handle.close(); }
+}
+
+function parseJSON(text, code) {
+  try { return JSON.parse(text); } catch { fail(code); }
+}
+
+async function configuration(home) {
+  const config = parseJSON(await readLocal(path.join(home, "config.json")), "INVALID_CONFIG");
+  if (!config || config.version !== 1 || !["org", "air"].includes(config.site)
+      || typeof config.userId !== "string" || !/^[1-9][0-9]*$/.test(config.userId)
+      || Object.keys(config).some(k => !["version", "site", "userId"].includes(k))) fail("INVALID_CONFIG");
+  return config;
+}
+
+async function credentials(home) {
+  const config = await configuration(home);
+  const cookie = (await readLocal(path.join(home, "github-cookie.txt"))).trim();
+  if (!cookie) fail("NOT_CONFIGURED");
+  return { type: "api", metadata: { site: config.site, userId: config.userId, githubCookie: cookie } };
+}
+
+async function readState(home) {
+  const text = await readLocal(path.join(home, "state.json"), true);
+  if (text === undefined) return undefined;
+  const s = parseJSON(text, "INVALID_STATE");
+  if (!s || s.version !== 1 || typeof s.identity !== "string" || !/^(org|air):[1-9][0-9]*$/.test(s.identity)
+      || typeof s.paused !== "boolean" || !Number.isSafeInteger(s.lastAttemptAt) || s.lastAttemptAt < 0
+      || !Number.isSafeInteger(s.nextAttemptAt) || s.nextAttemptAt < 0
+      || (s.lastOutcome !== null && s.lastOutcome !== "interrupted" && !RESULTS.has(s.lastOutcome))
+      || (s.lastOutcome === null ? (s.lastAttemptAt !== 0 || s.nextAttemptAt !== 0)
+          : s.nextAttemptAt !== s.lastAttemptAt + DAY)) fail("INVALID_STATE");
+  return s;
+}
+
+async function writeState(home, state) {
+  // Never write the auth object, response body, OAuth code or exception text.
+  const temporary = path.join(home, ".state-" + randomUUID() + ".tmp");
+  try {
+    await fs.writeFile(temporary, JSON.stringify(state, null, 2) + "\n", { flag: "wx", mode: 0o600 });
+    await fs.rename(temporary, path.join(home, "state.json"));
+  } finally { await fs.rm(temporary, { force: true }); }
+}
+
+async function locked(home, action) {
+  const file = path.join(home, "run.lock");
+  let handle;
+  try { handle = await fs.open(file, "wx", 0o600); }
+  catch (error) { if (error.code === "EEXIST") return { outcome: "busy" }; throw error; }
+  const token = randomUUID();
+  try {
+    await handle.writeFile(JSON.stringify({ pid: process.pid, token }));
+    return await action();
+  } finally {
+    await handle.close();
+    const current = parseJSON(await readLocal(file), "LOCK_CHANGED");
+    if (current.token !== token) fail("LOCK_CHANGED");
+    await fs.unlink(file);
+  }
+}
+
+export async function initialize(home = defaultHome()) {
+  home = await homePath(home, true);
+  for (const [name, text] of [["config.json", JSON.stringify({ version: 1, site: "org", userId: "" }, null, 2) + "\n"], ["github-cookie.txt", ""]]) {
+    try { await fs.writeFile(path.join(home, name), text, { flag: "wx", mode: 0o600 }); }
+    catch (error) { if (error.code !== "EEXIST") throw error; await readLocal(path.join(home, name)); }
+  }
+  return { initialized: true, home };
+}
+
+export async function status(home = defaultHome()) {
+  home = await homePath(home);
+  let configured = false;
+  try { await credentials(home); configured = true; }
+  catch (error) { if (!(error instanceof LocalError) || !["NOT_CONFIGURED", "INVALID_CONFIG"].includes(error.code)) throw error; }
+  const state = await readState(home);
+  return { configured, paused: state?.paused ?? false, nextAttemptAt: state?.nextAttemptAt ?? null, lastOutcome: state?.lastOutcome ?? null };
+}
+
+async function defaultCheckin(auth) {
+  const { default: plugin } = await import("./index.mjs");
+  return (await plugin()).auth.checkin(async () => auth, {});
+}
+
+export async function runOnce(home = defaultHome(), { now = Date.now, checkin = defaultCheckin } = {}) {
+  home = await homePath(home);
+  return locked(home, async () => {
+    const auth = await credentials(home);
+    const identity = auth.metadata.site + ":" + auth.metadata.userId;
+    const state = await readState(home);
+    if (state && state.identity !== identity) return { outcome: "paused", reason: "ACCOUNT_CHANGED" };
+    if (state?.paused) return { outcome: "paused", reason: "MANUAL_RECOVERY_REQUIRED" };
+    const at = now();
+    if (!Number.isSafeInteger(at) || at < 0 || !Number.isSafeInteger(at + DAY)) fail("INVALID_CLOCK");
+    if (state && at < state.nextAttemptAt) return { outcome: "skipped", reason: "NOT_DUE" };
+    // Persist a fail-closed reservation BEFORE any network side effect.
+    const pending = { version: 1, identity, lastAttemptAt: at, nextAttemptAt: at + DAY, paused: true, lastOutcome: "interrupted" };
+    await writeState(home, pending);
+    let outcome = "failed";
+    try {
+      const result = await checkin(auth);
+      if (RESULTS.has(result?.outcome)) outcome = result.outcome;
+    } catch { /* Intentionally do not log exception text: it may contain secrets. */ }
+    await writeState(home, { ...pending, paused: outcome !== "claimed" && outcome !== "done", lastOutcome: outcome });
+    return { outcome };
+  });
+}
+
+export async function resume(home = defaultHome()) {
+  home = await homePath(home);
+  return locked(home, async () => {
+    const config = await configuration(home);
+    const previous = await readState(home); // Corrupt state must not be silently discarded.
+    const state = previous || { version: 1, lastAttemptAt: 0, nextAttemptAt: 0, lastOutcome: null };
+    await writeState(home, { ...state, identity: config.site + ":" + config.userId, paused: false });
+    return { resumed: true, networkRequested: false };
+  });
+}
+
+export async function watch(home = defaultHome(), { signal, report = r => console.log(JSON.stringify(r)), poll = ms => sleep(ms, undefined, { signal }) } = {}) {
+  let previous;
+  while (!signal?.aborted) {
+    const result = await runOnce(home);
+    const text = JSON.stringify(result);
+    if (text !== previous) report(result);
+    previous = text;
+    if (["failed", "ineligible", "paused", "busy"].includes(result.outcome)) return result;
+    try { await poll(60_000); }
+    catch (error) { if (!signal?.aborted) throw error; }
+  }
+  return { stopped: true };
+}
+
+const HELP =   "Local HTTP only. No browser automation or browser-session extraction.\n" +
+  "Usage: node local-checkin.mjs <init|status|run|watch|resume> [--home ABSOLUTE_DIRECTORY]\n" +
+  "run/watch: at most one attempt per 24h; failure pauses until explicit resume.\n" +
+  "resume: after manual recovery only; keeps the 24h cooldown and makes no request.\n" +
+  "Never pass a Cookie on the command line or in chat. Data stays in your local user directory.";
+
+async function main(argv) {
+  const [command = "help", ...rest] = argv;
+  if (["help", "--help", "-h"].includes(command)) { console.log(HELP); return; }
+  if (rest.length && (rest.length !== 2 || rest[0] !== "--home" || !path.isAbsolute(rest[1]))) fail("INVALID_ARGUMENTS");
+  const home = rest[1] || defaultHome();
+  const actions = { init: initialize, status, run: runOnce, resume };
+  let result;
+  if (command === "watch") {
+    const stop = new AbortController();
+    const onStop = () => stop.abort();
+    process.once("SIGINT", onStop);
+    process.once("SIGTERM", onStop);
+    try { result = await watch(home, { signal: stop.signal }); }
+    finally { process.off("SIGINT", onStop); process.off("SIGTERM", onStop); }
+  } else {
+    if (!Object.hasOwn(actions, command)) fail("INVALID_ARGUMENTS");
+    result = await actions[command](home);
+    console.log(JSON.stringify(result));
+  }
+  if (["failed", "ineligible", "paused", "busy"].includes(result?.outcome)) process.exitCode = 2;
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  main(process.argv.slice(2)).catch(error => {
+    console.error(JSON.stringify({ error: error instanceof LocalError ? error.code : "LOCAL_OPERATION_FAILED" }));
+    process.exitCode = 1;
+  });
+}

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "opencode-agentrouter-auth",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.6",
+  "description": "AgentRouter (agentrouter.org) provider for magpie and OpenCode: GitHub or API-key sign-in, configurable request headers, balance and the daily check-in",
+  "type": "module",
+  "main": "./index.mjs",
+  "exports": "./index.mjs",
+  "files": [
+    "index.mjs",
+    "response.mjs",
+    "request.mjs",
+    "body-inspection.mjs",
+    "github-cookie.mjs",
+    "content-filter.mjs",
+    "content-filter.example.json",
+    "local-checkin.mjs",
+    "LOCAL-CHECKIN.md",
+    "README.md",
+    "CHANGELOG.md",
+    "docs/OPTIMIZATION.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "magpie",
+    "magpie-plugin",
+    "agentrouter",
+    "llm-gateway"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ZhaoJun233/agentrouter-magpie-plugin.git"
+  },
+  "magpie": {
+    "maxConcurrency": 2
+  },
+  "scripts": {
+    "test": "node --test body-inspection.test.mjs usage.test.mjs loader-stream.test.mjs response-bounds.test.mjs checkin.test.mjs local-checkin.test.mjs local-checkin.integration.test.mjs request-replay.test.mjs content-filter.test.mjs auth-guidance.test.mjs auth-flow.test.mjs resource-compat.test.mjs auth-request-boundary.test.mjs response-preservation.test.mjs",
+    "test:headers": "python3 set-ar-headers.test.py"
+  }
 }

package/request.mjs

@@ -0,0 +1,94 @@
+import { redactResponsesBody } from "./content-filter.mjs";
+import { readCloneText } from "./body-inspection.mjs";
+
+// Replay complete items inline instead of asking a load-balanced resource to
+// retrieve them by an old item ID. Never remove call_id or opaque contents.
+function isInlinePart(part) {
+  if (!part || typeof part !== "object") return false;
+  if (["input_text", "input_image", "input_file", "input_audio"].includes(part.type)) return true;
+  if (part.type !== "output_text" || typeof part.text !== "string") return false;
+  // The gateway also emits logprobs: [] on ordinary completed text. Empty
+  // probability metadata adds no content; populated or unknown data stays intact.
+  return Object.keys(part).every(key => ["type", "text", "annotations", "logprobs"].includes(key)) &&
+    (part.annotations == null || Array.isArray(part.annotations) && part.annotations.length === 0) &&
+    (!Object.hasOwn(part, "logprobs") || Array.isArray(part.logprobs) && part.logprobs.length === 0);
+}
+
+function hasInlineContent(item) {
+  if (!item || typeof item !== "object") return false;
+  switch (item.type) {
+    case undefined:
+    case "message":
+      return ["user", "assistant", "system", "developer"].includes(item.role) &&
+        Object.keys(item).every(key => ["type", "id", "role", "content", "status", "phase"].includes(key)) &&
+        (typeof item.content === "string" && item.content.length > 0 ||
+          Array.isArray(item.content) && item.content.length > 0 && item.content.every(isInlinePart));
+    case "function_call":
+      return typeof item.call_id === "string" && item.call_id.length > 0 &&
+        typeof item.name === "string" && item.name.length > 0 && typeof item.arguments === "string";
+    case "function_call_output":
+      return typeof item.call_id === "string" && item.call_id.length > 0 &&
+        (typeof item.output === "string" || Array.isArray(item.output));
+    // Reasoning IDs are required by the published input schema; encrypted
+    // state has no cross-resource portability guarantee. Preserve it intact.
+    case "reasoning":
+      return false;
+    default:
+      return false;
+  }
+}
+
+const MAX_BODY = 4 * 1024 * 1024;
+
+export async function prepareResponsesRequest(input, init = {}) {
+  return prepareRequest(input, init);
+}
+
+export async function prepareRequest(input, init = {}, { portableResponses = true, textFilter = null } = {}) {
+  if (!portableResponses && !textFilter) return init;
+  const request = input instanceof Request ? input : null;
+  let pathname;
+  try { pathname = new URL(request ? request.url : input).pathname; } catch { return init; }
+  if (!pathname.endsWith("/responses") || (init.method ?? request?.method ?? "GET").toUpperCase() !== "POST") return init;
+  const headers = new Headers(request?.headers);
+  new Headers(init.headers ?? {}).forEach((v, k) => headers.set(k, v));
+  if (headers.has("content-encoding") && headers.get("content-encoding").toLowerCase() !== "identity") return init;
+  const mediaType = headers.get("content-type")?.split(";", 1)[0].trim().toLowerCase();
+  if (mediaType && mediaType !== "application/json" && !mediaType.endsWith("+json")) return init;
+  let text = init.body;
+  if (text == null && request) text = await readCloneText(request, {
+    maxBytes: MAX_BODY, timeoutMs: 2000, signal: init.signal ?? request.signal,
+  });
+  if (typeof text !== "string" || text.length > MAX_BODY || new TextEncoder().encode(text).byteLength > MAX_BODY) return init;
+  let body;
+  try { body = JSON.parse(text); } catch { return init; }
+  if (!body || typeof body !== "object" || Array.isArray(body)) return init;
+  const filtered = redactResponsesBody(body, textFilter);
+  body = filtered.body;
+  const replayed = portableResponses && replayInline(body);
+  if (!filtered.replacements && !replayed) return init;
+  if (replayed) body.store = false;
+  for (const name of ["content-length", "content-md5", "digest", "content-digest"]) headers.delete(name);
+  return { ...init, body: JSON.stringify(body), headers };
+}
+
+function replayInline(body) {
+  // Pointers carry context we cannot retrieve. Filtering visible prose must not
+  // silently discard that context or turn a continuation into a new conversation.
+  if (!Array.isArray(body.input) || body.previous_response_id || body.conversation ||
+      body.input.some(item => item?.type === "item_reference")) return false;
+  let changed = false;
+  for (const item of body.input) {
+    if (!hasInlineContent(item) || !Object.hasOwn(item, "id")) continue;
+    delete item.id;
+    if (item.type === "message" || item.type == null) {
+      // Output-message input objects require an ID. Convert to the supported
+      // EasyInputMessage form, preserving phase and every actual text segment.
+      delete item.status;
+      if (Array.isArray(item.content)) item.content = item.content.map(part =>
+        part.type === "output_text" ? { type: "input_text", text: part.text } : part);
+    }
+    changed = true;
+  }
+  return changed;
+}