@stringsync/splates 0.0.0-stage → 0.0.45

package/index-d4hjrzaq.js

@@ -0,0 +1,464 @@
+import {
+  legacyName,
+  legacyWarnings
+} from "./index-k73tsw5g.js";
+
+// agent-stream.ts
+import { Dispatcher } from "webappwiz/events";
+
+class AgentStream2 {
+  process;
+  readable;
+  writable;
+  dispatcher = new Dispatcher;
+  events = this.dispatcher.events;
+  base;
+  frames = [];
+  more = Promise.withResolvers();
+  ended = false;
+  partial = "";
+  _seq = 0;
+  _dispatched = 0;
+  _lastId = null;
+  _asking = null;
+  midFrame = false;
+  detaching = null;
+  writer = null;
+  writing = Promise.resolve();
+  constructor(process, { base = 0 } = {}) {
+    this.process = process;
+    this.base = base;
+    this.read(process.output);
+    this.readable = new ReadableStream({
+      pull: (controller) => this.pull(controller),
+      cancel: () => {
+        this.ended = true;
+        this.more.resolve();
+      }
+    }, { highWaterMark: 0 });
+    this.writable = new WritableStream({
+      write: (message) => this.send(this.outgoing(message)),
+      close: () => this.input().close(),
+      abort: (reason) => this.input().abort(reason)
+    });
+  }
+  get seq() {
+    return this._seq;
+  }
+  get dispatched() {
+    return this._dispatched;
+  }
+  get lastId() {
+    return this._lastId;
+  }
+  get asking() {
+    return this._asking;
+  }
+  detach() {
+    this.detaching ??= Promise.withResolvers();
+    if (!this.midFrame) {
+      this.detaching.resolve();
+    }
+    return this.detaching.promise;
+  }
+  respond(id, answer) {
+    return this.send({ jsonrpc: "2.0", id, ...answer });
+  }
+  async read(frames) {
+    const decoder = new TextDecoder;
+    try {
+      for await (const frame of frames) {
+        this.partial += decoder.decode(frame.bytes, { stream: true });
+        if (!this.partial.endsWith(`
+`)) {
+          continue;
+        }
+        const lines = this.partial.split(`
+`);
+        this.partial = "";
+        this.frames.push({ seq: frame.seq, messages: lines.flatMap(parse) });
+        this.more.resolve();
+      }
+    } catch {} finally {
+      this.ended = true;
+      this.more.resolve();
+    }
+  }
+  async pull(controller) {
+    for (;; ) {
+      if (this.detaching !== null && !this.midFrame) {
+        this.detaching.resolve();
+        return new Promise(() => {});
+      }
+      const frame = this.frames[0];
+      if (frame === undefined) {
+        if (this.ended) {
+          controller.close();
+          return;
+        }
+        await this.more.promise;
+        this.more = Promise.withResolvers();
+        continue;
+      }
+      const message = frame.messages.shift();
+      if (message === undefined) {
+        this.finish(frame);
+        continue;
+      }
+      this._seq = frame.seq;
+      this.midFrame = true;
+      const kept = this.incoming(message);
+      if (kept === null) {
+        continue;
+      }
+      this._asking = "method" in kept && "id" in kept && kept.id !== undefined ? kept.id : null;
+      this.dispatcher.dispatch("handling", frame.seq);
+      controller.enqueue(kept);
+      await settled();
+      if (frame.messages.length === 0) {
+        this.finish(frame);
+      }
+      return;
+    }
+  }
+  finish(frame) {
+    this.frames.shift();
+    this.midFrame = false;
+    this._dispatched = frame.seq;
+    this.dispatcher.dispatch("dispatched", frame.seq);
+  }
+  incoming(message) {
+    if ("method" in message || typeof message.id !== "number") {
+      return message;
+    }
+    if (message.id < this.base) {
+      this.dispatcher.dispatch("stale", message);
+      return null;
+    }
+    return { ...message, id: message.id - this.base };
+  }
+  outgoing(message) {
+    if (!("method" in message) || !("id" in message)) {
+      return message;
+    }
+    if (typeof message.id !== "number") {
+      return message;
+    }
+    const id = message.id + this.base;
+    this._lastId = id;
+    this.dispatcher.dispatch("request", { id, method: message.method });
+    return { ...message, id };
+  }
+  send(message) {
+    const line = new TextEncoder().encode(`${JSON.stringify(message)}
+`);
+    const written = this.writing.then(() => this.input().write(line));
+    this.writing = written.catch(() => {});
+    return written;
+  }
+  input() {
+    this.writer ??= this.process.input.getWriter();
+    return this.writer;
+  }
+}
+function parse(line) {
+  const trimmed = line.trim();
+  if (trimmed === "") {
+    return [];
+  }
+  try {
+    const message = JSON.parse(trimmed);
+    return typeof message === "object" && message !== null ? [message] : [];
+  } catch {
+    return [];
+  }
+}
+function settled() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+
+// agent-process.ts
+import * as acp from "@agentclientprotocol/sdk";
+import { Duration as Duration2 } from "webappwiz/time";
+
+// legacy-ps.ts
+import {
+  NodePs
+} from "webappwiz/system";
+class LegacyNamesPs {
+  inner;
+  constructor(inner) {
+    this.inner = inner;
+  }
+  get platform() {
+    return this.inner.platform;
+  }
+  get pid() {
+    return this.inner.pid;
+  }
+  get hostname() {
+    return this.inner.hostname;
+  }
+  get args() {
+    return this.inner.args;
+  }
+  get self() {
+    return this.inner.self;
+  }
+  env(name) {
+    const value = this.inner.env(name);
+    const old = legacyName(name);
+    if (value !== undefined || old === null) {
+      return value;
+    }
+    const legacy = this.inner.env(old);
+    if (legacy !== undefined) {
+      legacyWarnings.once(old, name);
+    }
+    return legacy;
+  }
+  alive(pid) {
+    return this.inner.alive(pid);
+  }
+  spawn(argv, opts) {
+    return this.inner.spawn(argv, withLegacyEnv(opts));
+  }
+  spawnCapture(argv, opts) {
+    return this.inner.spawnCapture(argv, withLegacyEnv(opts));
+  }
+  start(argv, opts) {
+    return this.inner.start(argv, withLegacyEnv(opts));
+  }
+  startOnTerminal(argv, opts) {
+    return this.inner.startOnTerminal(argv, withLegacyEnv(opts));
+  }
+  processes() {
+    return this.inner.processes();
+  }
+  listening() {
+    return this.inner.listening();
+  }
+  cwd() {
+    return this.inner.cwd();
+  }
+  cd(path) {
+    this.inner.cd(path);
+  }
+  exit(code) {
+    this.inner.exit(code);
+  }
+  on(signal, handler) {
+    return this.inner.on(signal, handler);
+  }
+  once(event, handler) {
+    return this.inner.once(event, handler);
+  }
+}
+function systemPs() {
+  return new LegacyNamesPs(new NodePs);
+}
+function withLegacyEnv(opts) {
+  if (opts === undefined || opts.env === undefined && opts.unset === undefined) {
+    return opts;
+  }
+  const env = { ...opts.env };
+  for (const [name, value] of Object.entries(opts.env ?? {})) {
+    const old = legacyName(name);
+    if (old !== null && !(old in env)) {
+      env[old] = value;
+    }
+  }
+  const unset = (opts.unset ?? []).flatMap((name) => {
+    const old = legacyName(name);
+    return old === null ? [name] : [name, old];
+  });
+  return {
+    ...opts,
+    ...opts.env === undefined ? {} : { env },
+    ...opts.unset === undefined ? {} : { unset }
+  };
+}
+
+// supervise.ts
+import { Duration, SystemTimer } from "webappwiz/time";
+var RESTART = 75;
+var UPDATE = 76;
+var SERVING = "SPLATES_DEV_SERVING";
+var UNBUILT = "SPLATES_DEV_UNBUILT";
+var NEWEST = ["bunx", "@stringsync/splates@latest"];
+var WORKER_PAUSE = Duration.secs(1);
+async function supervise(ps, {
+  build = null,
+  env = {},
+  cwd,
+  worker = null,
+  timer = new SystemTimer
+} = {}) {
+  let splates = ps.self;
+  let argv = [...splates, ...ps.args];
+  let building = build;
+  const quiet = ps.on("SIGINT", () => {});
+  const stopping = new AbortController;
+  let stopped = 0;
+  const stopOn = (signal, code) => ps.on(signal, () => {
+    stopped = code;
+    stopping.abort();
+  });
+  const terminated = stopOn("SIGTERM", 128 + 15);
+  const hungUp = stopOn("SIGHUP", 128 + 1);
+  const working = new AbortController;
+  if (worker !== null) {
+    keep(ps, () => [...splates, ...worker], {
+      env,
+      cwd,
+      signal: working.signal,
+      timer
+    });
+  }
+  try {
+    for (;; ) {
+      const built = building === null || (await ps.spawn(building.argv, { cwd: building.cwd })).exitCode === 0;
+      if (stopping.signal.aborted) {
+        return stopped;
+      }
+      let exitCode;
+      try {
+        ({ exitCode } = await ps.spawn(argv, {
+          env: {
+            ...env,
+            [SERVING]: "1",
+            ...built ? {} : { [UNBUILT]: "1" }
+          },
+          cwd,
+          signal: stopping.signal
+        }));
+      } catch (error) {
+        if (stopping.signal.aborted) {
+          return stopped;
+        }
+        throw error;
+      }
+      if (exitCode === UPDATE) {
+        splates = NEWEST;
+        argv = [...splates, ...ps.args];
+        building = null;
+      } else if (exitCode !== RESTART) {
+        return exitCode;
+      }
+    }
+  } finally {
+    working.abort();
+    quiet.dispose();
+    terminated.dispose();
+    hungUp.dispose();
+  }
+}
+async function keep(ps, argv, { timer, ...opts }) {
+  while (!opts.signal.aborted) {
+    await ps.spawn(argv(), opts).catch(() => {});
+    await new Promise((resolve) => {
+      const pause = timer.setTimeout(resolve, WORKER_PAUSE);
+      opts.signal.addEventListener("abort", () => {
+        pause.dispose();
+        resolve();
+      }, { once: true });
+    });
+  }
+}
+
+// agent-process.ts
+function framed2(bytes) {
+  let seq = 0;
+  return bytes.pipeThrough(new TransformStream({
+    transform: (chunk, controller) => controller.enqueue({ bytes: chunk, seq: ++seq })
+  }));
+}
+function launcherOf(launch) {
+  return {
+    launch,
+    resume: (handle) => {
+      throw new Error(`nothing here takes back channel ${handle.channel} of worker ${handle.worker}`);
+    }
+  };
+}
+var launch = (argv, cwd, env) => {
+  const child = systemPs().start(argv, { cwd, env, unset: [SERVING] });
+  let tail = "";
+  (async () => {
+    const decoder = new TextDecoder;
+    for await (const chunk of child.stderr) {
+      tail = (tail + decoder.decode(chunk)).slice(-STDERR_CHARS);
+    }
+  })().catch(() => {});
+  return {
+    pid: child.pid,
+    input: child.stdin,
+    output: framed2(child.stdout),
+    ack: () => {},
+    handle: null,
+    stderr: () => tail,
+    exited: child.exited.catch((error) => {
+      tail = `cannot start ${argv[0]} in ${cwd}: ${error instanceof Error ? error.message : String(error)}`;
+      return 127;
+    }),
+    kill: () => child.kill()
+  };
+};
+var STDERR_CHARS = 2000;
+var LIST_WAIT = Duration2.secs(30);
+var LIST_PAGES = 10;
+async function listSessions(agent, cwd, run, timer) {
+  const process = run(agent.argv, cwd, {});
+  let timeout = null;
+  try {
+    const connection = new acp.ClientSideConnection(() => ({
+      sessionUpdate: async () => {},
+      requestPermission: async () => ({ outcome: { outcome: "cancelled" } })
+    }), new AgentStream2(process));
+    const listing = (async () => {
+      const initialized = await connection.initialize({
+        protocolVersion: acp.PROTOCOL_VERSION,
+        clientCapabilities: {}
+      });
+      const capabilities = initialized.agentCapabilities;
+      if (capabilities?.loadSession !== true || capabilities.sessionCapabilities?.list == null) {
+        return [];
+      }
+      const sessions = [];
+      let cursor = null;
+      for (let page = 0;page < LIST_PAGES; page++) {
+        const listed = await connection.listSessions({
+          cwd,
+          cursor
+        });
+        for (const each of listed.sessions) {
+          if (each.cwd === cwd) {
+            sessions.push({
+              agent: agent.id,
+              session: each.sessionId,
+              title: each.title ?? null,
+              updatedAt: each.updatedAt ?? null
+            });
+          }
+        }
+        cursor = listed.nextCursor ?? null;
+        if (cursor === null) {
+          break;
+        }
+      }
+      return sessions;
+    })();
+    const gaveUp = new Promise((_, reject) => {
+      timeout = timer.setTimeout(() => reject(new Error(`${agent.name} did not list its sessions`)), LIST_WAIT);
+    });
+    const died = process.exited.then((code) => {
+      throw new Error(`${agent.name} exited with code ${code}`);
+    });
+    return await Promise.race([listing, gaveUp, died]);
+  } finally {
+    timeout?.dispose();
+    process.kill();
+  }
+}
+
+export { AgentStream2, systemPs, RESTART, UPDATE, SERVING, UNBUILT, supervise, framed2, launcherOf, launch, listSessions };