accelr8 3.8.1 → 4.0.0-next.1

package/dist/chunks/chunk-3OTVRBTJ.js

@@ -0,0 +1,265 @@
+#!/usr/bin/env node
+import {
+  AuthLockTimeout,
+  credentialsKey,
+  deleteCredentials,
+  loadCredentials,
+  loadLegacyIdentity,
+  loadTokens,
+  saveCredentials,
+  withAuthLock
+} from "./chunk-FVC2UPMV.js";
+import {
+  PORT,
+  VERSION
+} from "./chunk-5QXGOLQ3.js";
+
+// src/authclient.ts
+import os from "node:os";
+import { createHash } from "node:crypto";
+var sha256hex = (s) => createHash("sha256").update(s).digest("hex");
+function legacyProofs(serverUrl, baseDir) {
+  const server = credentialsKey(serverUrl);
+  const out = [];
+  for (const [key, token] of Object.entries(loadTokens(baseDir))) {
+    const i = key.indexOf(":");
+    if (i <= 0 || !token) continue;
+    out.push({ projectId: key.slice(0, i), handle: key.slice(i + 1), proof: sha256hex(sha256hex(token) + "\n" + server) });
+    if (out.length >= 20) break;
+  }
+  return out;
+}
+var REFRESH_EARLY_MS = 6e4;
+function httpBase(serverUrl) {
+  const key = credentialsKey(serverUrl);
+  return key.replace(/^wss:/, "https:").replace(/^ws:/, "http:");
+}
+function approveUrl(serverUrl) {
+  return httpBase(serverUrl) + "/approve";
+}
+var AuthNetworkError = class extends Error {
+};
+async function call(url, init = {}) {
+  let res;
+  try {
+    res = await fetch(url, {
+      method: init.method ?? (init.body === void 0 ? "GET" : "POST"),
+      headers: {
+        ...init.body === void 0 ? {} : { "content-type": "application/json" },
+        ...init.bearer ? { authorization: `Bearer ${init.bearer}` } : {}
+      },
+      body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
+      signal: AbortSignal.timeout(15e3)
+    });
+  } catch (e) {
+    throw new AuthNetworkError(`could not reach ${new URL(url).origin}: ${e instanceof Error ? e.message : e}`);
+  }
+  let data = null;
+  try {
+    data = await res.json();
+  } catch {
+  }
+  return { status: res.status, data };
+}
+function toCredentials(serverUrl, r, now = Date.now()) {
+  return {
+    server: credentialsKey(serverUrl),
+    user: { id: r.user.id, name: r.user.name, color: r.user.color },
+    sessionId: r.sessionId,
+    accessToken: r.accessToken,
+    accessExpiresAt: now + r.accessExpiresIn * 1e3,
+    refreshToken: r.refreshToken,
+    refreshExpiresAt: now + r.refreshExpiresIn * 1e3,
+    signedInAt: now
+  };
+}
+var isTokens = (d) => !!d && typeof d.accessToken === "string" && typeof d.refreshToken === "string" && !!d.user;
+function defaultName() {
+  try {
+    return os.userInfo().username;
+  } catch {
+    return process.env.USER || "guest";
+  }
+}
+var OLDER_SERVER = /* @__PURE__ */ new Set([404, 405, 426]);
+function olderServerMessage(serverUrl) {
+  return [
+    `${credentialsKey(serverUrl)} runs an older accelr8 with no sign-in yet, so this version can't use it.`,
+    "To try this version, start your own server in another terminal:",
+    `    accelr8 serve --host 127.0.0.1`,
+    "then open accelr8 on it:",
+    `    accelr8 --server ws://127.0.0.1:${PORT}`
+  ].join("\n  ");
+}
+async function deviceLogin(serverUrl, opts = {}) {
+  const print = opts.print ?? ((l) => console.log(l));
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const base = httpBase(serverUrl);
+  const legacy = loadLegacyIdentity(opts.baseDir);
+  const startRes = await call(`${base}/auth/device`, {
+    body: {
+      machine: (opts.machine ?? os.hostname()).slice(0, 64),
+      platform: process.platform,
+      name: opts.name || legacy.name || defaultName(),
+      legacyId: legacy.id,
+      legacyName: legacy.name,
+      // old ids were public: the old projects come along only with proof
+      legacyProof: legacy.id ? legacyProofs(serverUrl, opts.baseDir) : void 0,
+      version: VERSION
+    }
+  });
+  if (startRes.status !== 200 || typeof startRes.data?.deviceCode !== "string") {
+    if (!startRes.data?.message && OLDER_SERVER.has(startRes.status)) throw new Error(olderServerMessage(serverUrl));
+    throw new Error(startRes.data?.message || `the server refused to start a sign-in (HTTP ${startRes.status})`);
+  }
+  const start = startRes.data;
+  print("");
+  print(`  To sign in, open this page in your browser:`);
+  print(`    ${approveUrl(serverUrl)}`);
+  print(`  and type this code:`);
+  print(`    ${start.userCode}`);
+  print("");
+  print(`  Waiting for you to approve it. The code expires in ${Math.round(start.expiresIn / 60)} minutes.`);
+  await opts.onCode?.(start);
+  let interval = Math.max(1, start.interval) * 1e3;
+  const deadline = Date.now() + start.expiresIn * 1e3;
+  for (; ; ) {
+    const r = await call(`${base}/auth/device/token`, { body: { deviceCode: start.deviceCode } });
+    if (r.status === 200 && isTokens(r.data)) {
+      const creds = toCredentials(serverUrl, r.data);
+      saveCredentials(creds, opts.baseDir);
+      return creds;
+    }
+    if (r.status === 200 && r.data?.pending) {
+    } else if (r.data?.error === "slow_down") interval += 5e3;
+    else throw new Error(r.data?.message || `sign-in failed (HTTP ${r.status})`);
+    if (Date.now() + interval > deadline) throw new Error("The code expired. Run accelr8 login again for a new one.");
+    await sleep(interval);
+  }
+}
+async function refreshCredentials(serverUrl, opts = {}) {
+  const before = loadCredentials(serverUrl, opts.baseDir);
+  try {
+    return await withAuthLock(async () => {
+      const creds = loadCredentials(serverUrl, opts.baseDir);
+      if (!creds) return null;
+      if (!opts.force && creds.accessExpiresAt - Date.now() > REFRESH_EARLY_MS) return creds;
+      if (opts.force && before && creds.refreshToken !== before.refreshToken) return creds;
+      const r = await call(`${httpBase(serverUrl)}/auth/refresh`, { body: { refreshToken: creds.refreshToken } });
+      if (r.status === 200 && isTokens(r.data)) {
+        const next = { ...toCredentials(serverUrl, r.data), signedInAt: creds.signedInAt };
+        saveCredentials(next, opts.baseDir);
+        return next;
+      }
+      if (r.data?.error === "invalid_grant") {
+        deleteCredentials(serverUrl, opts.baseDir, (saved) => saved.refreshToken === creds.refreshToken);
+        return null;
+      }
+      throw new AuthNetworkError(`refresh failed (HTTP ${r.status})`);
+    }, opts.baseDir, opts.lock);
+  } catch (e) {
+    if (!(e instanceof AuthLockTimeout)) throw e;
+    const now = loadCredentials(serverUrl, opts.baseDir);
+    if (now && (!before || now.refreshToken !== before.refreshToken)) return now;
+    throw new AuthNetworkError("another accelr8 process is refreshing this sign-in; trying again shortly");
+  }
+}
+async function getAccessToken(serverUrl, opts = {}) {
+  const creds = loadCredentials(serverUrl, opts.baseDir);
+  if (!creds) return null;
+  if (!opts.force && creds.accessExpiresAt - Date.now() > REFRESH_EARLY_MS) return { token: creds.accessToken, creds };
+  try {
+    const next = await refreshCredentials(serverUrl, opts);
+    return next ? { token: next.accessToken, creds: next } : null;
+  } catch (e) {
+    if (e instanceof AuthNetworkError) return { token: creds.accessToken, creds };
+    throw e;
+  }
+}
+async function logout(serverUrl, opts = {}) {
+  const creds = loadCredentials(serverUrl, opts.baseDir);
+  if (!creds) return { wasSignedIn: false, revoked: null };
+  let revoked = null;
+  try {
+    const r = await call(`${httpBase(serverUrl)}/auth/logout`, { body: { refreshToken: creds.refreshToken, all: opts.all === true }, bearer: creds.accessToken });
+    if (r.status === 200) revoked = Number(r.data?.revoked ?? 0);
+  } catch {
+  }
+  deleteCredentials(serverUrl, opts.baseDir);
+  return { wasSignedIn: true, user: creds.user, revoked };
+}
+async function whoami(serverUrl, opts = {}) {
+  const local = loadCredentials(serverUrl, opts.baseDir);
+  if (!local) return null;
+  let tok;
+  try {
+    tok = await getAccessToken(serverUrl, opts);
+  } catch {
+    tok = { token: local.accessToken, creds: local };
+  }
+  if (!tok) return null;
+  try {
+    let r = await call(`${httpBase(serverUrl)}/auth/me`, { bearer: tok.token });
+    if (r.status === 401) {
+      const again = await getAccessToken(serverUrl, { ...opts, force: true });
+      if (!again) return null;
+      tok = again;
+      r = await call(`${httpBase(serverUrl)}/auth/me`, { bearer: tok.token });
+    }
+    if (r.status === 200 && r.data?.user) {
+      const user = r.data.user;
+      if (user.name !== tok.creds.user.name || user.color !== tok.creds.user.color) {
+        saveCredentials({ ...tok.creds, user: { id: user.id, name: user.name, color: user.color } }, opts.baseDir);
+      }
+      return { server: tok.creds.server, user, machine: r.data.session?.machine, since: r.data.session?.createdAt, verified: true };
+    }
+    return { server: tok.creds.server, user: tok.creds.user, since: tok.creds.signedInAt, verified: false, note: `server answered HTTP ${r.status}` };
+  } catch (e) {
+    return { server: tok.creds.server, user: tok.creds.user, since: tok.creds.signedInAt, verified: false, note: e instanceof Error ? e.message : String(e) };
+  }
+}
+async function signedInCall(serverUrl, route, body, baseDir) {
+  const tok = await getAccessToken(serverUrl, { baseDir });
+  if (!tok) throw new Error(`This machine is not signed in to ${credentialsKey(serverUrl)}. Run accelr8 login first.`);
+  return call(`${httpBase(serverUrl)}${route}`, { body, bearer: tok.token });
+}
+async function pendingSignIn(serverUrl, userCode, opts = {}) {
+  const r = await signedInCall(serverUrl, "/auth/device/pending", { userCode }, opts.baseDir);
+  if (r.status !== 200 || typeof r.data?.machine !== "string") throw new Error(r.data?.message || `the server refused (HTTP ${r.status})`);
+  return r.data;
+}
+async function approveSignIn(serverUrl, userCode, opts = {}) {
+  const r = await signedInCall(serverUrl, "/auth/device/approve", { userCode }, opts.baseDir);
+  if (r.status !== 200 || !r.data?.user) throw new Error(r.data?.message || `the server refused (HTTP ${r.status})`);
+  return r.data.user;
+}
+async function ensureSignedIn(serverUrl, opts = {}) {
+  const have = loadCredentials(serverUrl, opts.baseDir);
+  if (have) return have;
+  const print = opts.print ?? ((l) => console.log(l));
+  print(`You are not signed in to ${credentialsKey(serverUrl)} yet.`);
+  try {
+    const creds = await deviceLogin(serverUrl, opts);
+    print(`  Signed in as ${creds.user.name}. Opening accelr8...`);
+    return creds;
+  } catch (e) {
+    print(`  ${e instanceof Error ? e.message : e}`);
+    return null;
+  }
+}
+
+export {
+  legacyProofs,
+  httpBase,
+  approveUrl,
+  AuthNetworkError,
+  olderServerMessage,
+  deviceLogin,
+  refreshCredentials,
+  getAccessToken,
+  logout,
+  whoami,
+  pendingSignIn,
+  approveSignIn,
+  ensureSignedIn
+};

package/dist/chunks/chunk-5QXGOLQ3.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+// src/protocol.ts
+var VERSION = true ? "4.0.0-next.1" : "4.0.0-next.1";
+var PROTO = 4;
+var PORT = 8787;
+var USER_COLORS = [39, 213, 220, 46, 208, 141, 51, 203, 118, 165];
+function colorForId(id) {
+  let h = 0;
+  for (const ch of id) h = h * 31 + ch.charCodeAt(0) >>> 0;
+  return USER_COLORS[h % USER_COLORS.length];
+}
+var DEFAULT_SERVER = "wss://accelr8-canvas.patonchain.workers.dev";
+var CANVAS_W = 100;
+var CANVAS_H = 30;
+var LIMITS = {
+  chatMaxCp: 4e3,
+  // code points per chat message
+  chatMaxJson: 8192,
+  // serialized bytes per chat message
+  chatPerWindow: 10,
+  // messages per 10s per session
+  chatTail: 50,
+  // messages delivered in `joined`
+  chatPage: 50,
+  // default history page (max 100)
+  chatSyncMaxGap: 200,
+  // bigger gap -> full resync
+  chatRetain: 2e3,
+  // messages kept per project
+  draftMinIntervalMs: 100,
+  // server drops faster arrivals
+  draftMaxCp: 4e3,
+  // Frame budgets, per connection, per 10s window. cursor and paint have their
+  // own budgets because they are continuous by nature (the client sends cursor
+  // at 25/s, and one paint per cell while dragging): over budget they are
+  // DROPPED, never a disconnect. So do the executor frames an owner's terminal
+  // streams back (agentAccept/Delta/Done/Error: each reply sends up to 10
+  // deltas a second, and one terminal may run several replies at once): over
+  // budget a delta is dropped, and the frames that start or end a reply always
+  // pass. Everything else shares framesPerWindow, and a connection over
+  // hardFramesPerWindow in total is closed as a flood.
+  framesPerWindow: 200,
+  // other frames per 10s -> disconnect
+  cursorPerWindow: 400,
+  // cursor frames per 10s (client sends <= 250) -> drop extras
+  paintPerWindow: 1500,
+  // paint frames per 10s (fast drags burst) -> drop extras
+  execPerWindow: 1e3,
+  // executor frames per 10s (10 replies at once) -> drop extra deltas
+  hardFramesPerWindow: 4e3,
+  // all non-voice frames per 10s -> disconnect
+  invokesPerProjectMin: 20,
+  triggersPerUserMin: 6,
+  // messages that @mention an agent, per user per minute
+  // Wrong join codes. A code is the only way into a project, so guesses are
+  // limited three ways: per account, per network (an IPv4 address or an IPv6
+  // /64; a network that keeps hitting it is locked out for 10, 20, 40...
+  // minutes, up to 6 hours), and server-wide. Right codes are never counted.
+  joinGuessesPerMin: 5,
+  // per signed-in user (was per connection)
+  joinGuessesPerNet: 10,
+  // per network per 10 minutes
+  joinGuessesServerPerMin: 60,
+  // all wrong codes on the server, per minute
+  joinCodeLength: 8,
+  // 32 symbols, uniform: 40 bits
+  renamesPerHour: 10,
+  revealsPerMin: 10,
+  secretsPerProject: 50,
+  secretValueMax: 8192,
+  agentQueueCap: 5,
+  agentMaxDepth: 3,
+  agentBudgetPerTrigger: 5,
+  agentRepeatPerChain: 2,
+  voiceFramesPerSec: 50,
+  // ~25/s real, 2x headroom; exempt from framesPerWindow
+  voiceFrameMaxB64: 4096
+  // a 40ms s16le mono chunk is ~1.7KB base64; cap slack
+};
+var DEFAULT_ACCESS = { mode: "owner", users: [] };
+function encode(msg) {
+  return JSON.stringify(msg);
+}
+function decode(data) {
+  return JSON.parse(data);
+}
+
+export {
+  VERSION,
+  PROTO,
+  PORT,
+  colorForId,
+  DEFAULT_SERVER,
+  CANVAS_W,
+  CANVAS_H,
+  LIMITS,
+  DEFAULT_ACCESS,
+  encode,
+  decode
+};

package/dist/chunks/chunk-62O2F73J.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+// src/home.ts
+import os from "node:os";
+import path from "node:path";
+function accelr8Dir() {
+  const override = process.env.ACCELR8_HOME;
+  return override && override.trim() ? path.resolve(override) : path.join(os.homedir(), ".accelr8");
+}
+
+export {
+  accelr8Dir
+};

package/dist/chunks/chunk-CAQJPW54.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+
+// src/livekit-token.ts
+function isVoiceUrl(url) {
+  try {
+    const u = new URL(url);
+    return ["ws:", "wss:", "http:", "https:"].includes(u.protocol) && !!u.hostname && !u.username && !u.password;
+  } catch {
+    return false;
+  }
+}
+function parseVoiceIdentity(identity) {
+  const m = /^sess:([A-Za-z0-9_.@-]{1,128})$/.exec(identity);
+  return m ? { sid: m[1] } : null;
+}
+function sanitizeVoiceName(v, maxCp = 32) {
+  let out = "";
+  let n = 0;
+  for (const ch of String(v ?? "")) {
+    if (n >= maxCp) break;
+    const cp = ch.codePointAt(0);
+    if (cp < 32 || cp >= 127 && cp <= 159) continue;
+    if (cp >= 8203 && cp <= 8207 || cp >= 8234 && cp <= 8238 || cp >= 8294 && cp <= 8297 || cp === 65279) continue;
+    out += ch;
+    n++;
+  }
+  return out.trim() || "guest";
+}
+function decodeVoiceMetadata(raw) {
+  if (typeof raw !== "string" || !raw || raw.length > 2048) return null;
+  try {
+    const o = JSON.parse(raw);
+    if (!o || typeof o !== "object" || o.v !== 1) return null;
+    return {
+      v: 1,
+      sid: typeof o.sid === "string" ? o.sid.slice(0, 128) : "",
+      userId: typeof o.userId === "string" ? o.userId.slice(0, 64) : "",
+      name: sanitizeVoiceName(o.name),
+      color: Number.isInteger(o.color) ? o.color : 7,
+      client: o.client === "web" ? "web" : "tui"
+    };
+  } catch {
+    return null;
+  }
+}
+var enc = new TextEncoder();
+
+// src/livekit-core.ts
+function initialVoiceState(room = "", identity = "") {
+  return {
+    connection: "connecting",
+    room,
+    identity,
+    muted: true,
+    participants: [],
+    inputDeviceId: null,
+    playbackBlocked: false,
+    needsClick: false,
+    error: null,
+    endReason: null
+  };
+}
+var CONNECTIONS = ["connecting", "connected", "reconnecting", "disconnected"];
+var REASONS = ["left", "replaced", "removed", "room_closed", "network", "error", "window_closed"];
+function normalizeVoiceState(raw) {
+  if (!raw || typeof raw !== "object") return {};
+  const r = raw;
+  const out = {};
+  if (typeof r.connection === "string" && CONNECTIONS.includes(r.connection)) out.connection = r.connection;
+  if (typeof r.room === "string") out.room = r.room.slice(0, 256);
+  if (typeof r.identity === "string") out.identity = r.identity.slice(0, 256);
+  if (typeof r.muted === "boolean") out.muted = r.muted;
+  if (typeof r.playbackBlocked === "boolean") out.playbackBlocked = r.playbackBlocked;
+  if (typeof r.needsClick === "boolean") out.needsClick = r.needsClick;
+  if (r.inputDeviceId === null || typeof r.inputDeviceId === "string") out.inputDeviceId = r.inputDeviceId === null ? null : r.inputDeviceId.slice(0, 256);
+  if (r.error === null || typeof r.error === "string") out.error = r.error === null ? null : sanitizeText(r.error, 200);
+  if (r.endReason === null || typeof r.endReason === "string" && REASONS.includes(r.endReason)) out.endReason = r.endReason ?? null;
+  if (Array.isArray(r.participants)) {
+    out.participants = r.participants.slice(0, 100).flatMap((p) => {
+      if (!p || typeof p !== "object") return [];
+      const q = p;
+      if (typeof q.identity !== "string" || !q.identity) return [];
+      return [{
+        identity: q.identity.slice(0, 256),
+        sid: typeof q.sid === "string" ? q.sid.slice(0, 128) : null,
+        userId: typeof q.userId === "string" ? q.userId.slice(0, 64) : null,
+        name: sanitizeVoiceName(q.name),
+        color: Number.isInteger(q.color) ? q.color : null,
+        client: q.client === "web" ? "web" : q.client === "tui" ? "tui" : null,
+        isLocal: q.isLocal === true,
+        muted: q.muted !== false,
+        speaking: q.speaking === true
+      }];
+    });
+  }
+  return out;
+}
+function sanitizeText(s, max) {
+  let out = "";
+  for (const ch of s) {
+    const cp = ch.codePointAt(0);
+    if (cp < 32 || cp >= 127 && cp <= 159 || cp >= 8234 && cp <= 8238 || cp >= 8294 && cp <= 8297) continue;
+    out += ch;
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function sortParticipants(list) {
+  return [...list].sort((a, b) => a.isLocal !== b.isLocal ? a.isLocal ? -1 : 1 : a.name.localeCompare(b.name) || a.identity.localeCompare(b.identity));
+}
+var VoiceStore = class {
+  state;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this.state = initial;
+  }
+  snapshot() {
+    return this.state;
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => {
+      this.listeners.delete(fn);
+    };
+  }
+  update(patch) {
+    const prev = this.state;
+    if (prev.connection === "disconnected" && prev.endReason) return;
+    const next = { ...prev, ...patch };
+    if (patch.participants) next.participants = sortParticipants(patch.participants);
+    if (prev.endReason && !next.endReason) next.endReason = prev.endReason;
+    if (next.connection === "disconnected") {
+      next.participants = [];
+      next.muted = true;
+      next.needsClick = false;
+    }
+    if (JSON.stringify(prev) === JSON.stringify(next)) return;
+    this.state = next;
+    for (const fn of [...this.listeners]) {
+      try {
+        fn(next);
+      } catch {
+      }
+    }
+  }
+};
+function mapLiveKitDisconnect(code, wasConnected = false) {
+  if (code === void 0 && wasConnected) return "network";
+  switch (code) {
+    case 1:
+      return "left";
+    // CLIENT_INITIATED
+    case 2:
+      return "replaced";
+    // DUPLICATE_IDENTITY
+    case 4:
+      return "removed";
+    // PARTICIPANT_REMOVED
+    case 5:
+    case 10:
+      return "room_closed";
+    case 3:
+    case 7:
+    case 9:
+    case 14:
+    case 15:
+      return "network";
+    default:
+      return "error";
+  }
+}
+var RTC_NODE = "@livekit/rtc-node";
+var RTC_NODE_VERSION = "1.2.1";
+function rtcNodeMissingHint() {
+  return `in-terminal voice needs ${RTC_NODE}@${RTC_NODE_VERSION} \xB7 npm i -g ${RTC_NODE}@${RTC_NODE_VERSION} \xB7 or /voice for the window`;
+}
+function describeEnd(reason) {
+  switch (reason) {
+    case "left":
+      return "voice off";
+    case "replaced":
+      return "voice moved to another window";
+    case "removed":
+      return "you were removed from voice";
+    case "room_closed":
+      return "the voice room closed";
+    case "network":
+      return "voice lost its connection";
+    case "window_closed":
+      return "voice off \xB7 the voice window closed";
+    case "error":
+      return "voice stopped because of an error";
+    default:
+      return "voice off";
+  }
+}
+
+export {
+  isVoiceUrl,
+  parseVoiceIdentity,
+  sanitizeVoiceName,
+  decodeVoiceMetadata,
+  initialVoiceState,
+  normalizeVoiceState,
+  VoiceStore,
+  mapLiveKitDisconnect,
+  RTC_NODE,
+  RTC_NODE_VERSION,
+  rtcNodeMissingHint,
+  describeEnd
+};