@jigging/jig 0.1.0-alpha.5 → 0.1.0-alpha.7

package/libexec/agent/pi-agent-launcher.js

@@ -0,0 +1,196 @@
+#!/jig-runtime/bun
+// @bun
+
+// src/internal/pi-agent-launcher.ts
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  readSync,
+  writeFileSync,
+  writeSync
+} from "fs";
+import { spawn } from "child_process";
+var STARTUP_INPUT_BYTES = 64 * 1024;
+var PI_HOME = "/tmp/pi-home";
+var PI_AGENT_DIR = "/tmp/pi-agent";
+var CREDENTIAL_PATH = `${PI_AGENT_DIR}/auth.json`;
+var SETTINGS_PATH = `${PI_AGENT_DIR}/settings.json`;
+var MODELS_PATH = `${PI_AGENT_DIR}/models.json`;
+var NATIVE_PI_PATH = "/agent/pi";
+var ADAPTER_SPECIFIER = "./pi-acp.js";
+var MAX_OUTPUT_TOKENS = 4096;
+var PROVIDER = /^[a-z0-9][a-z0-9._-]{0,127}$/;
+var SELECTION = /^[A-Za-z0-9][A-Za-z0-9._:/+-]{0,255}$/;
+var decoder = new TextDecoder("utf-8", { fatal: true });
+var PRIVATE_PI_NATIVE_ARGUMENTS = Object.freeze([
+  "--mode",
+  "rpc",
+  "--no-session",
+  "--no-tools",
+  "--no-extensions",
+  "--no-skills",
+  "--no-prompt-templates",
+  "--no-themes",
+  "--no-context-files",
+  "--no-approve",
+  "--offline"
+]);
+var PRIVATE_PI_SETTINGS = Object.freeze({
+  defaultProjectTrust: "never",
+  enableAnalytics: false,
+  enableInstallTelemetry: false,
+  enableSkillCommands: false,
+  extensions: Object.freeze([]),
+  packages: Object.freeze([]),
+  prompts: Object.freeze([]),
+  quietStartup: true,
+  retry: Object.freeze({
+    enabled: false,
+    maxRetries: 0,
+    provider: Object.freeze({ maxRetries: 0 })
+  }),
+  skills: Object.freeze([]),
+  themes: Object.freeze([]),
+  compaction: Object.freeze({ enabled: false }),
+  images: Object.freeze({ blockImages: true })
+});
+if (import.meta.main)
+  await main();
+async function main() {
+  const startup = process.env.JIG_PI_STARTUP_INPUT;
+  if (startup === undefined) {
+    await launchNativePi();
+    return;
+  }
+  if (startup !== "credential")
+    throw new Error("Pi startup input mode is invalid");
+  const provider = requireProvider(process.env.JIG_PI_PROVIDER);
+  const model = requireSelection(process.env.JIG_PI_MODEL, "Pi model");
+  mkdirSync(PI_HOME, { recursive: false, mode: 448 });
+  mkdirSync(PI_AGENT_DIR, { recursive: false, mode: 448 });
+  materializeCredential(provider);
+  writeFileSync(SETTINGS_PATH, JSON.stringify(PRIVATE_PI_SETTINGS), {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  writeFileSync(MODELS_PATH, JSON.stringify(privatePiModels(provider, model)), {
+    encoding: "utf8",
+    flag: "wx",
+    mode: 384
+  });
+  delete process.env.JIG_PI_STARTUP_INPUT;
+  await import(ADAPTER_SPECIFIER);
+}
+function privatePiModels(provider, model) {
+  return {
+    providers: {
+      [requireProvider(provider)]: {
+        modelOverrides: {
+          [requireSelection(model, "Pi model")]: { maxTokens: MAX_OUTPUT_TOKENS }
+        }
+      }
+    }
+  };
+}
+function materializeCredential(provider) {
+  const header = readExactly(4);
+  const size = new DataView(header.buffer, header.byteOffset, header.byteLength).getUint32(0, false);
+  if (size === 0 || size > STARTUP_INPUT_BYTES - 4) {
+    throw new Error("Pi startup input is invalid");
+  }
+  const credential = readExactly(size);
+  let descriptor;
+  try {
+    const parsed = JSON.parse(decoder.decode(credential));
+    if (!isRecord(parsed) || !exactKeys(parsed, [provider])) {
+      throw new Error("Pi startup input is invalid");
+    }
+    const entry = parsed[provider];
+    if (!isRecord(entry) || entry.type !== (provider === "openrouter" ? "api_key" : "oauth")) {
+      throw new Error("Pi startup input is invalid");
+    }
+    descriptor = openSync(CREDENTIAL_PATH, "wx", 384);
+    writeExactly(descriptor, credential);
+  } catch {
+    throw new Error("Pi startup input is invalid");
+  } finally {
+    credential.fill(0);
+    if (descriptor !== undefined)
+      closeSync(descriptor);
+  }
+}
+async function launchNativePi() {
+  if (process.argv.slice(2).join("\x00") !== ["--mode", "rpc", "--no-themes"].join("\x00")) {
+    throw new Error("pi-acp native invocation is invalid");
+  }
+  const provider = requireProvider(process.env.JIG_PI_PROVIDER);
+  const model = requireSelection(process.env.JIG_PI_MODEL, "Pi model");
+  const child = spawn(NATIVE_PI_PATH, [
+    ...PRIVATE_PI_NATIVE_ARGUMENTS,
+    "--provider",
+    provider,
+    "--model",
+    model
+  ], {
+    cwd: "/work",
+    env: process.env,
+    stdio: "inherit"
+  });
+  const forward = (signal) => {
+    if (!child.killed)
+      child.kill(signal);
+  };
+  process.once("SIGINT", forward);
+  process.once("SIGTERM", forward);
+  const exitCode = await new Promise((resolve, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => resolve(code ?? (signal === null ? 1 : 128)));
+  });
+  process.removeListener("SIGINT", forward);
+  process.removeListener("SIGTERM", forward);
+  process.exitCode = exitCode;
+}
+function readExactly(size) {
+  const result = new Uint8Array(size);
+  let offset = 0;
+  while (offset < result.byteLength) {
+    const count = readSync(0, result, offset, result.byteLength - offset, null);
+    if (count === 0)
+      throw new Error("Pi startup input ended early");
+    offset += count;
+  }
+  return result;
+}
+function writeExactly(descriptor, value) {
+  let offset = 0;
+  while (offset < value.byteLength) {
+    offset += writeSync(descriptor, value, offset, value.byteLength - offset, null);
+  }
+}
+function requireProvider(value) {
+  if (typeof value !== "string" || !PROVIDER.test(value)) {
+    throw new Error("Pi provider is invalid");
+  }
+  return value;
+}
+function requireSelection(value, label) {
+  if (typeof value !== "string" || !SELECTION.test(value)) {
+    throw new Error(`${label} is invalid`);
+  }
+  return value;
+}
+function exactKeys(value, expected) {
+  const keys = Object.keys(value).sort();
+  const sorted = [...expected].sort();
+  return keys.length === sorted.length && keys.every((key, index) => key === sorted[index]);
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export {
+  privatePiModels,
+  PRIVATE_PI_SETTINGS,
+  PRIVATE_PI_NATIVE_ARGUMENTS
+};