@jigging/jig 0.1.0-alpha.1 → 0.1.0-alpha.11

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

@@ -0,0 +1,197 @@
+#!/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 !== "api-key" && startup !== "subscription") {
+    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, startup === "api-key" ? "api_key" : "oauth");
+  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, type) {
+  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 !== type) {
+      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
+};

package/libexec/evaluator/project-authoring-1.schema.json

@@ -20,6 +20,12 @@
       "minLength": 1,
       "maxLength": 1024
     },
+    "targetSelector": {
+      "type": "string",
+      "description": "An exact flow:<project-relative-path> or binding:<LocalName> selector. Jig additionally validates the prefix and canonical target identity.",
+      "minLength": 6,
+      "maxLength": 1029
+    },
     "discoverSource": {
       "type": "object",
       "properties": {
@@ -95,12 +101,20 @@
         "settings": {
           "type": "object",
           "maxProperties": 65536
+        },
+        "slots": {
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/$defs/targetSelector"
+          },
+          "maxProperties": 256
         }
       },
       "required": [
         "kind",
         "package",
-        "settings"
+        "settings",
+        "slots"
       ],
       "additionalProperties": false
     },

package/libexec/evaluator/project-evaluator-sdk.bundle.js

@@ -1754,6 +1754,7 @@ function compareProjectPaths(left, right) {
 }
 
 // src/project/author.ts
+var LOCAL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var GLOB_CHARACTERS = /[*?\[\]{}]/;
 function discover(roots) {
   const values = typeof roots === "string" ? [roots] : snapshotStringArray(roots, "roots");
@@ -1782,9 +1783,15 @@ function normalizeJig(input, canonical) {
 function defineBinding(input) {
   return normalizeBinding(input, false);
 }
+function flowRef(path) {
+  return record({ kind: "flow", path: normalizeProjectPath(path, "Flow reference") });
+}
+function bindingRef(id) {
+  return record({ kind: "binding", id: validateLocalName(id, "Binding reference") });
+}
 function normalizeBinding(input, canonical) {
   const captured = snapshotJsonObject(input, "Binding definition");
-  assertClosedObject(captured, canonical ? ["kind", "package", "settings"] : ["package", "settings"], "Binding definition");
+  assertClosedObject(captured, canonical ? ["kind", "package", "settings", "slots"] : ["package", "settings", "slots"], "Binding definition");
   if (canonical && captured.kind !== "package") {
     throw new TypeError("Binding kind must be package");
   }
@@ -1792,7 +1799,30 @@ function normalizeBinding(input, canonical) {
     throw new TypeError("Binding package is required");
   const packagePath = normalizeProjectPath(captured.package, "package");
   const settings = Object.hasOwn(captured, "settings") ? expectJsonObject(captured.settings, "settings") : emptyRecord();
-  return record({ kind: "package", package: packagePath, settings });
+  const slots = Object.hasOwn(captured, "slots") ? normalizeFlowSlots(captured.slots) : emptyRecord();
+  return record({ kind: "package", package: packagePath, settings, slots });
+}
+function normalizeFlowSlots(value) {
+  const input = snapshotJsonObject(value, "slots");
+  if (Object.keys(input).length > 256) {
+    throw new TypeError("slots exceed 256 entries");
+  }
+  const output = Object.create(null);
+  for (const name of Object.keys(input).sort(compareUtf8)) {
+    validateLocalName(name, "slot name");
+    const target = parseRunTargetSelector(input[name], `slot ${name}`);
+    output[name] = target.kind === "flow" ? `flow:${target.path}` : `binding:${target.id}`;
+  }
+  return Object.freeze(output);
+}
+function parseRunTargetSelector(value, label) {
+  if (typeof value !== "string")
+    throw new TypeError(`${label} must be a target selector`);
+  if (value.startsWith("flow:"))
+    return flowRef(normalizeProjectPath(value.slice(5), label));
+  if (value.startsWith("binding:"))
+    return bindingRef(validateLocalName(value.slice(8), label));
+  throw new TypeError(`${label} must select flow:<path> or binding:<id>`);
 }
 function normalizeSource(value, field, canonical) {
   if (value === undefined)
@@ -1836,6 +1866,12 @@ function normalizeUniquePaths(values, label, rejectGlob) {
   assertNoProjectPathCollisions(paths, label);
   return Object.freeze(paths);
 }
+function validateLocalName(value, label) {
+  if (typeof value !== "string" || value.length > 64 || !LOCAL_NAME.test(value)) {
+    throw new TypeError(`${label} must be a LocalName`);
+  }
+  return value;
+}
 function snapshotJsonObject(value, label) {
   const snapshot = snapshotJson(value, label);
   validateJson1(snapshot);