Embed the engine

import { randomBytes } from "node:crypto";
import { dirCheckpoints, model, openEngine, Principal, sqliteStore } from "@pistishq/sdk/engine";
import { relaySandboxes } from "@pistishq/sdk/hands";
import { dockerKind, ensureRelayContainer } from "@pistishq/sdk/sandbox-docker";
import { sourceControl } from "@pistishq/sdk/scm";
import { githubApp } from "@pistishq/sdk/scm/github";

// Keep the relay's key, so a restarted relay accepts the sandboxes it already has.
const adminKey = process.env.PISTIS_RELAY_KEY ?? randomBytes(24).toString("hex");
const relay = await ensureRelayContainer({ name: "pistis-relay", adminKey, stateVolume: "pistis-relay" });
const boxes = dockerKind.create({ namespace: "prod", relayContainer: relay.name, allow: ["npm"] });
const sandboxes = relaySandboxes({ relay: { url: relay.url, adminKey }, handsUrl: relay.handsUrl, boxes });
const github = githubApp.create({ appId: "12345", privateKey: process.env.GITHUB_APP_KEY ?? "" });

const engine = await openEngine({
  store: sqliteStore(".pistis/brain.sqlite"),     // the directory must exist; or postgresStore(url)
  model: await model("anthropic/<model-id>"),     // the key comes from ANTHROPIC_API_KEY
  checkpoints: { store: dirCheckpoints(".pistis/checkpoints") },
  sandboxes,
  // Clones on the server into /workspace/repo; adds the publish tool (push + pull request).
  plugins: [sourceControl({ resolve: async (s) => {
    const repo = await github.repo("acme/api");
    return repo && { host: github, repo, requestedBy: { principal: s.principal, name: String(s.principal) } };
  } })],
});

const s = await engine.create({ requestId: "ticket-123", principal: Principal("alice"), agent: { instructions: "You fix failing tests." } });
const { submissionId } = await engine.send(s.sessionId, "fix the failing test", "msg-1");
const settled = await engine.settled(s.sessionId, submissionId);
if (settled.status !== "done") throw new Error(`the turn ended unanswered: ${settled.reason}`); // e.g. model_error

import { defineTool } from "@pistishq/sdk/engine";

const deploy = defineTool({
  name: "deploy_preview",
  description: "Deploy this session's branch to a preview environment.",
  parameters: { type: "object", properties: { branch: { type: "string" } }, required: ["branch"] },
  run: async ({ branch }, { sessionId, principal }) => ({ text: await previews.deploy(String(branch), principal) }),
});
await openEngine({ /* … */ plugins: [{ name: "previews", tools: [deploy] }], approvals: { tools: ["deploy_preview"] } });

import { createHttpSurface } from "@pistishq/cli";
const token = process.env.PISTIS_TOKEN;          // at least 16 characters
if (!token) throw new Error("PISTIS_TOKEN required");
createHttpSurface({ sessions: engine, token }).listen(7777, "127.0.0.1");

import { httpSessions } from "@pistishq/sdk";

const pistis = httpSessions("https://pistis.example.com", { token: process.env.PISTIS_TOKEN });
const s = await pistis.create({ requestId: "ticket-123" });
await pistis.send(s.sessionId, "fix the failing test", "msg-1");
for await (const e of pistis.follow(s.sessionId)) {
  if (e.kind === "approval" && e.decided === undefined) await pistis.decide(s.sessionId, e.key, true);
  else if (e.kind !== "approval") console.log(e.seq, e.kind, e.text);
}