@tonbo/cli 0.0.5 → 0.0.7

package/dist/bin/tonbo.js

@@ -0,0 +1,1981 @@
+#!/usr/bin/env node
+
+// src/app.ts
+import { Command } from "commander";
+import { readFileSync } from "node:fs";
+
+// src/api.ts
+import { createHash, randomUUID } from "node:crypto";
+
+// src/http.ts
+var HttpError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+  }
+};
+async function requestJson(fetcher, url, init = {}) {
+  const response = await fetcher(url, init);
+  const body = await response.json().catch(() => null);
+  if (!response.ok) {
+    const record = body && typeof body === "object" ? body : {};
+    const message = [record.detail, record.message, record.error, record.title].find(
+      (value) => typeof value === "string"
+    );
+    throw new HttpError(
+      typeof message === "string" ? message : `Request failed with HTTP ${response.status}.`,
+      response.status,
+      body
+    );
+  }
+  return body;
+}
+
+// src/api.ts
+function stableJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+}
+function digest(value) {
+  return createHash("sha256").update(stableJson(value)).digest("hex");
+}
+var TonboApi = class {
+  constructor(fetcher, accountOrigin = "https://tonbo.dev", managementOrigin = "https://api.tonbo.dev") {
+    this.fetcher = fetcher;
+    this.accountOrigin = accountOrigin;
+    this.managementOrigin = managementOrigin;
+  }
+  listProjects(oauthToken) {
+    return requestJson(
+      this.fetcher,
+      `${this.accountOrigin}/api/cli/projects`,
+      {
+        headers: { authorization: `Bearer ${oauthToken}` }
+      }
+    ).then((body) => body.projects);
+  }
+  createProject(oauthToken, slug, name) {
+    return requestJson(
+      this.fetcher,
+      `${this.accountOrigin}/api/cli/projects`,
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${oauthToken}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ slug, ...name ? { name } : {} })
+      }
+    ).then((body) => body.project);
+  }
+  registerSshKey(oauthToken, key) {
+    return requestJson(
+      this.fetcher,
+      `${this.accountOrigin}/api/cli/ssh-keys`,
+      {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${oauthToken}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          algorithm: key.algorithm,
+          key_base64: key.keyBase64,
+          label: key.label
+        })
+      }
+    ).then((body) => body.key);
+  }
+  revokeSshKey(oauthToken, fingerprint) {
+    return requestJson(
+      this.fetcher,
+      `${this.accountOrigin}/api/cli/ssh-keys`,
+      {
+        method: "DELETE",
+        headers: {
+          authorization: `Bearer ${oauthToken}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ fingerprint })
+      }
+    ).then((body) => body.key);
+  }
+  exchangeManagementToken(oauthToken, projectId) {
+    return requestJson(
+      this.fetcher,
+      `${this.accountOrigin}/api/cli/projects/${projectId}/token`,
+      {
+        method: "POST",
+        headers: { authorization: `Bearer ${oauthToken}` }
+      }
+    ).then((body) => body.access_token);
+  }
+  async deploy({
+    bundle,
+    projectId,
+    spec,
+    token
+  }) {
+    const descriptor = {
+      format: bundle.format,
+      sha256: bundle.sha256,
+      size_bytes: bundle.size_bytes
+    };
+    const projectPath = `/v1/projects/${projectId}`;
+    const bundlesPath = `${projectPath}/source-bundles`;
+    const prepared = await this.management("PUT", `${bundlesPath}/${bundle.sha256}`, token, {
+      format: descriptor.format,
+      size_bytes: descriptor.size_bytes
+    });
+    if (prepared.status === "upload") {
+      if (!prepared.upload_url) throw new Error("Tonbo did not return a source upload URL.");
+      const uploaded = await this.fetcher(prepared.upload_url, {
+        method: "PUT",
+        headers: {
+          "content-type": prepared.content_type ?? "application/vnd.tonbo.source+tar",
+          "x-upsert": "false"
+        },
+        body: new Blob([new Uint8Array(bundle.bytes)])
+      });
+      let uploadError = null;
+      if (!uploaded.ok) {
+        uploadError = new Error(`Source upload failed with HTTP ${uploaded.status}.`);
+      }
+      try {
+        await this.management("POST", `${bundlesPath}/${bundle.sha256}/complete`, token, {
+          format: bundle.format,
+          size_bytes: bundle.size_bytes
+        });
+      } catch (error) {
+        if (uploadError)
+          throw new AggregateError([uploadError, error], "Source bundle upload did not complete.");
+        throw error;
+      }
+    }
+    const revisionsPath = `${projectPath}/revisions`;
+    const revisionDigest = digest(spec);
+    const revisions = await this.managementList(revisionsPath, token);
+    let revision = revisions.find((candidate) => candidate.spec_sha256 === revisionDigest);
+    if (!revision) {
+      revision = (await this.management("POST", revisionsPath, token, { spec })).data;
+    }
+    const deploymentPath = `${projectPath}/deployment`;
+    const current = await this.management(
+      "GET",
+      deploymentPath,
+      token
+    ).catch((error) => {
+      if (error.status === 404) return null;
+      throw error;
+    });
+    const deployment = (await this.management("PUT", deploymentPath, token, {
+      desired_revision_id: revision.id,
+      desired_state: "running",
+      expected_generation: current ? Number(current.data.generation) : null
+    })).data;
+    return { deployment, revision };
+  }
+  async run({
+    projectId,
+    prompt,
+    sessionId,
+    token,
+    turnId = randomUUID()
+  }) {
+    const projectPath = `/v1/projects/${projectId}`;
+    const deployment = (await this.management("GET", `${projectPath}/deployment`, token)).data;
+    if (deployment.observed_state !== "running")
+      throw new Error(`Project Agent is ${deployment.observed_state}; wait for it to be running.`);
+    const session = sessionId ? { id: sessionId } : (await this.management(
+      "POST",
+      `${projectPath}/sessions`,
+      token,
+      { revision_id: deployment.desired_revision_id }
+    )).data;
+    const turn = (await this.management(
+      "POST",
+      `${projectPath}/sessions/${session.id}/turns`,
+      token,
+      { prompt },
+      turnId
+    )).data;
+    return { deployment, session, turn };
+  }
+  turnEvents({
+    after = 0,
+    projectId,
+    sessionId,
+    token,
+    turnId
+  }) {
+    return this.management(
+      "GET",
+      `/v1/projects/${projectId}/sessions/${sessionId}/turns/${turnId}/events?after=${after}`,
+      token
+    );
+  }
+  listProjectSecrets(projectId, token) {
+    return this.management(
+      "GET",
+      `/v1/projects/${projectId}/secrets`,
+      token
+    ).then((body) => body.data);
+  }
+  setProjectSecret(projectId, name, value, token) {
+    return this.management(
+      "PUT",
+      `/v1/projects/${projectId}/secrets/${encodeURIComponent(name)}`,
+      token,
+      { value }
+    );
+  }
+  deleteProjectSecret(projectId, name, token) {
+    return this.management(
+      "DELETE",
+      `/v1/projects/${projectId}/secrets/${encodeURIComponent(name)}`,
+      token
+    );
+  }
+  management(method, path7, token, body, idempotencyKey) {
+    return requestJson(this.fetcher, `${this.managementOrigin}${path7}`, {
+      method,
+      headers: {
+        authorization: `Bearer ${token}`,
+        ...body === void 0 ? {} : {
+          "content-type": "application/json",
+          "idempotency-key": idempotencyKey ?? randomUUID()
+        }
+      },
+      ...body === void 0 ? {} : { body: JSON.stringify(body) }
+    });
+  }
+  async managementList(path7, token) {
+    const values = [];
+    let cursor = null;
+    do {
+      const separator = path7.includes("?") ? "&" : "?";
+      const page = await this.management(
+        "GET",
+        `${path7}${separator}limit=100${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`,
+        token
+      );
+      values.push(...page.data);
+      cursor = page.next_cursor;
+    } while (cursor);
+    return values;
+  }
+};
+
+// src/agent-source.ts
+import { lstat, readFile } from "node:fs/promises";
+import path from "node:path";
+
+// ../../packages/agent-source-inspector/src/index.ts
+var AGENTS_INSTRUCTIONS_PATH = "AGENTS.md";
+var PI_SETTINGS_PATH = ".pi/settings.json";
+var MAX_HARNESS_CONFIG_BYTES = 256 * 1024;
+var supportedHarnesses = [
+  {
+    command: "pi",
+    id: "pi",
+    name: "PI"
+  }
+];
+var supportedExecutionTargets = [
+  { driver: "native", harness: "pi" },
+  { driver: "command", harness: "pi" }
+];
+var AgentSourceInspectionError = class extends Error {
+  constructor(code, path7, message, options) {
+    super(message, options);
+    this.code = code;
+    this.path = path7;
+    this.name = "AgentSourceInspectionError";
+  }
+};
+function parsePiPackageCount(contents) {
+  let settings;
+  try {
+    settings = JSON.parse(contents);
+  } catch (error) {
+    throw new AgentSourceInspectionError(
+      "invalid_pi_settings",
+      PI_SETTINGS_PATH,
+      `${PI_SETTINGS_PATH} must contain valid JSON.`,
+      { cause: error }
+    );
+  }
+  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {
+    throw new AgentSourceInspectionError(
+      "invalid_pi_settings",
+      PI_SETTINGS_PATH,
+      `${PI_SETTINGS_PATH} must contain a JSON object.`
+    );
+  }
+  if (!("packages" in settings)) return 0;
+  const packages = settings.packages;
+  if (!Array.isArray(packages)) {
+    throw new AgentSourceInspectionError(
+      "invalid_pi_settings",
+      PI_SETTINGS_PATH,
+      `${PI_SETTINGS_PATH} packages must be an array.`
+    );
+  }
+  return packages.length;
+}
+async function inspectAgentSource(source) {
+  const [agentsMd, piSettings] = await Promise.all([
+    source.has(AGENTS_INSTRUCTIONS_PATH),
+    source.readText(PI_SETTINGS_PATH, MAX_HARNESS_CONFIG_BYTES)
+  ]);
+  if (piSettings !== null) {
+    return {
+      version: 1,
+      instructions: { agentsMd },
+      harness: {
+        id: "pi",
+        reason: "pi_settings_found",
+        state: "identified"
+      },
+      pi: {
+        packageCount: parsePiPackageCount(piSettings),
+        settingsFound: true
+      }
+    };
+  }
+  return {
+    version: 1,
+    instructions: { agentsMd },
+    harness: {
+      candidates: supportedHarnesses.map((harness) => harness.id),
+      reason: "no_harness_specific_config",
+      state: "selection_required"
+    },
+    pi: {
+      packageCount: 0,
+      settingsFound: false
+    }
+  };
+}
+
+// src/agent-source.ts
+var LocalAgentSource = class {
+  constructor(root) {
+    this.root = root;
+  }
+  async has(filename) {
+    const metadata = await this.metadata(filename);
+    return metadata?.isFile() === true;
+  }
+  async readText(filename, maxBytes) {
+    const metadata = await this.metadata(filename);
+    if (!metadata) return null;
+    if (!metadata.isFile() || metadata.isSymbolicLink()) {
+      throw new Error(`${filename} must be a regular file.`);
+    }
+    if (metadata.size > maxBytes) {
+      throw new Error(`${filename} exceeds the ${maxBytes}-byte inspection limit.`);
+    }
+    return readFile(path.join(this.root, filename), "utf8");
+  }
+  async metadata(filename) {
+    try {
+      return await lstat(path.join(this.root, filename));
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+};
+function inspectLocalAgentSource(root) {
+  return inspectAgentSource(new LocalAgentSource(root));
+}
+
+// src/auth.ts
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// src/callback-page.ts
+var WORDMARK = [
+  "\u2588\u2588\u2588\u2580\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2580\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588",
+  "\u2588\u2588\u2584 \u2584\u2588\u2588\u2580\u2584 \u2588\u2588 \u2584\u2580\u2588\u2588 \u2584 \u2588\u2588 \u2584\u2580\u2588",
+  "\u2588\u2588\u2588\u2584\u2584\u2588\u2588\u2584\u2584\u2588\u2588\u2588\u2584\u2588\u2584\u2588\u2588\u2584\u2584\u2588\u2588\u2588\u2588\u2584\u2584\u2588"
+].join("\n");
+var OUTCOMES = {
+  complete: {
+    status: 200,
+    title: "You are signed in.",
+    body: "Return to your terminal. This tab can be closed."
+  },
+  denied: {
+    status: 400,
+    title: "Login was not completed.",
+    body: "Nothing was authorized. Return to your terminal to try again."
+  },
+  invalid: {
+    // The state did not match, the code was missing, or the path was wrong.
+    // Say that it could not be verified rather than which check failed: the
+    // person who can read this page is not necessarily the one who started
+    // the login.
+    status: 400,
+    title: "This callback could not be verified.",
+    body: "Return to your terminal and start the login again."
+  }
+};
+function renderCallbackPage(outcome) {
+  const { title, body } = OUTCOMES[outcome];
+  return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex">
+<title>Tonbo CLI</title>
+<style>
+  :root {
+    --paper: #f3f2ee;
+    --ink: #1d1b17;
+    --rule: #c9c5ba;
+    --quiet: #5c564a;
+    --signal: #d64a03;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --paper: #1d1b17;
+      --ink: #f3f2ee;
+      --rule: #3a362e;
+      --quiet: #a49e8f;
+      --signal: #f08b4b;
+    }
+  }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    min-height: 100vh;
+    display: grid;
+    grid-template-rows: auto 1fr;
+    padding: 0 clamp(20px, 5vw, 72px);
+    background: var(--paper);
+    color: var(--ink);
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, sans-serif;
+    -webkit-font-smoothing: antialiased;
+  }
+  header { padding: 28px 0; }
+  /* Same metrics as .auth-wordmark in the app: the glyphs are the ground
+     and the letters are the gaps, so the 8px/10px/scaleY(0.8) combination is
+     what makes the rows meet without seams. Iosevka is not available here,
+     so it falls back to the platform monospace. */
+  pre.wordmark {
+    margin: 0;
+    font-family: 'Iosevka', ui-monospace, 'SFMono-Regular', Menlo, Consolas, monospace;
+    font-size: 8px;
+    font-weight: 400;
+    line-height: 10px;
+    letter-spacing: 0;
+    white-space: pre;
+    color: var(--signal);
+    transform: scaleY(0.8);
+    transform-origin: left top;
+  }
+  main {
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    max-width: 46ch;
+    padding-bottom: 12vh;
+  }
+  h1 {
+    margin: 0;
+    font-size: 26px;
+    font-weight: 300;
+    line-height: 1.16;
+    letter-spacing: -0.018em;
+  }
+  p {
+    margin: 14px 0 0;
+    font-size: 16px;
+    line-height: 1.55;
+    color: var(--quiet);
+  }
+  hr {
+    width: 40px;
+    margin: 28px 0 0;
+    border: 0;
+    border-top: 1px solid var(--rule);
+  }
+</style>
+</head>
+<body>
+<header><pre class="wordmark" aria-hidden="true">${WORDMARK}</pre></header>
+<main>
+  <h1>${title}</h1>
+  <p>${body}</p>
+  <hr>
+</main>
+</body>
+</html>
+`;
+}
+function callbackResponse(outcome) {
+  return {
+    status: OUTCOMES[outcome].status,
+    headers: {
+      "content-type": "text/html; charset=utf-8",
+      "cache-control": "no-store"
+    },
+    body: renderCallbackPage(outcome)
+  };
+}
+
+// src/auth.ts
+var exec = promisify(execFile);
+var LOOPBACK_REDIRECT = "http://localhost:17655/callback";
+function base64url(value) {
+  return value.toString("base64url");
+}
+function withAbsoluteExpiry(tokens) {
+  if (tokens.expires_at || !Number.isInteger(tokens.expires_in) || (tokens.expires_in ?? 0) <= 0)
+    return tokens;
+  return {
+    ...tokens,
+    expires_at: Math.floor(Date.now() / 1e3) + (tokens.expires_in ?? 0)
+  };
+}
+var AuthClient = class {
+  constructor(credentials, fetcher, accountOrigin = "https://tonbo.dev", browserOpener = openBrowser) {
+    this.credentials = credentials;
+    this.fetcher = fetcher;
+    this.accountOrigin = accountOrigin;
+    this.browserOpener = browserOpener;
+  }
+  async accessToken() {
+    const injected = process.env.TONBO_ACCESS_TOKEN?.trim();
+    if (injected) return injected;
+    const tokens = await this.credentials.load();
+    if (!tokens) throw new Error("Not logged in. Run `tonbo login`.");
+    const legacyRelativeExpiry = !tokens.expires_at && tokens.expires_in;
+    if (!legacyRelativeExpiry && (!tokens.expires_at || tokens.expires_at > Math.floor(Date.now() / 1e3) + 30))
+      return tokens.access_token;
+    if (!tokens.refresh_token) throw new Error("Tonbo login expired. Run `tonbo login` again.");
+    const config = await this.config();
+    const refreshed = withAbsoluteExpiry(
+      await this.exchange(
+        config.token_endpoint,
+        new URLSearchParams({
+          client_id: config.client_id,
+          grant_type: "refresh_token",
+          refresh_token: tokens.refresh_token
+        })
+      )
+    );
+    if (!refreshed.refresh_token) refreshed.refresh_token = tokens.refresh_token;
+    await this.credentials.save(refreshed);
+    return refreshed.access_token;
+  }
+  async login(progress = () => {
+  }) {
+    progress({ status: "started", step: "account-config" });
+    const config = await this.config();
+    progress({ status: "completed", step: "account-config" });
+    if (config.redirect_uri !== LOOPBACK_REDIRECT)
+      throw new Error(`Unsupported OAuth redirect URI: ${config.redirect_uri}`);
+    const verifier = base64url(randomBytes(48));
+    const challenge = createHash2("sha256").update(verifier).digest("base64url");
+    const state = base64url(randomBytes(24));
+    const authorization = new URL(config.authorization_endpoint);
+    authorization.search = new URLSearchParams({
+      client_id: config.client_id,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      redirect_uri: config.redirect_uri,
+      response_type: "code",
+      scope: "openid profile email",
+      state
+    }).toString();
+    const code = await this.listenForCode(
+      state,
+      () => this.browserOpener(authorization.toString()),
+      progress
+    );
+    progress({ status: "started", step: "token-exchange" });
+    const tokens = withAbsoluteExpiry(
+      await this.exchange(
+        config.token_endpoint,
+        new URLSearchParams({
+          client_id: config.client_id,
+          code,
+          code_verifier: verifier,
+          grant_type: "authorization_code",
+          redirect_uri: config.redirect_uri
+        })
+      )
+    );
+    progress({ status: "completed", step: "token-exchange" });
+    progress({ status: "started", step: "credential-store" });
+    await this.credentials.save(tokens);
+    progress({ status: "completed", step: "credential-store" });
+    return tokens;
+  }
+  config() {
+    return requestJson(this.fetcher, `${this.accountOrigin}/api/cli/config`);
+  }
+  exchange(endpoint, body) {
+    return requestJson(this.fetcher, endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body
+    });
+  }
+  listenForCode(expectedState, ready, progress) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const sockets = /* @__PURE__ */ new Set();
+      let authorizationStarted = false;
+      const startAuthorization = () => {
+        if (authorizationStarted) return;
+        authorizationStarted = true;
+        progress({ status: "completed", step: "browser" });
+        progress({ status: "started", step: "browser-authorization" });
+      };
+      const finish = (result, completedResponseSocket) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        const complete = (closeError) => {
+          if (closeError) reject(closeError);
+          else if ("code" in result) {
+            progress({ status: "completed", step: "callback-close" });
+            resolve(result.code);
+          } else reject(result.error);
+        };
+        if ("code" in result) progress({ status: "started", step: "callback-close" });
+        if (!server.listening) {
+          complete();
+          return;
+        }
+        server.close(complete);
+        for (const socket of sockets) {
+          if (socket !== completedResponseSocket) socket.destroy();
+        }
+        server.closeIdleConnections();
+      };
+      const timeout = setTimeout(
+        () => {
+          finish({ error: new Error("Timed out waiting for browser login.") });
+        },
+        5 * 60 * 1e3
+      );
+      const server = createServer((request, response) => {
+        const url = new URL(request.url ?? "/", LOOPBACK_REDIRECT);
+        const code = url.searchParams.get("code");
+        const oauthError = url.searchParams.get("error_description") ?? url.searchParams.get("error");
+        if (oauthError) {
+          const responseSocket2 = response.socket;
+          respond(
+            response,
+            "denied",
+            () => finish({ error: new Error(oauthError) }, responseSocket2)
+          );
+          return;
+        }
+        if (url.pathname !== "/callback" || url.searchParams.get("state") !== expectedState || !code) {
+          respond(response, "invalid");
+          return;
+        }
+        startAuthorization();
+        progress({ status: "completed", step: "browser-authorization" });
+        const responseSocket = response.socket;
+        respond(response, "complete", () => finish({ code }, responseSocket));
+      });
+      server.on("connection", (socket) => {
+        sockets.add(socket);
+        socket.once("close", () => sockets.delete(socket));
+      });
+      server.once("error", (error) => finish({ error }));
+      progress({ status: "started", step: "callback-server" });
+      server.listen(17655, "localhost", () => {
+        progress({ status: "completed", step: "callback-server" });
+        progress({ status: "started", step: "browser" });
+        void ready().then(startAuthorization).catch(
+          (error) => finish({
+            error: error instanceof Error ? error : new Error("Could not open the login browser.")
+          })
+        );
+      });
+    });
+  }
+};
+function respond(response, outcome, finished) {
+  const page = callbackResponse(outcome);
+  if (finished) response.once("finish", finished);
+  response.writeHead(page.status, { ...page.headers, connection: "close" });
+  response.end(page.body);
+}
+async function openBrowser(url) {
+  if (process.platform === "darwin") return void await exec("open", [url]);
+  if (process.platform === "win32")
+    return void await exec("rundll32", ["url.dll,FileProtocolHandler", url]);
+  return void await exec("xdg-open", [url]);
+}
+
+// src/commands.ts
+import path4 from "node:path";
+
+// src/build.ts
+import { spawn } from "node:child_process";
+async function runBuildCommand(root, command) {
+  if (command.length === 0) throw new Error("Build command must not be empty.");
+  await new Promise((resolve, reject) => {
+    const child = spawn(command[0], command.slice(1), {
+      cwd: root,
+      env: process.env,
+      // Command output is progress, not the CLI result. Keep stdout available
+      // for the single JSON document emitted by `tonbo --json deploy`.
+      stdio: ["inherit", process.stderr, process.stderr]
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (code === 0) resolve();
+      else
+        reject(
+          new Error(
+            `Build command failed${signal ? ` with signal ${signal}` : ` with status ${code}`}.`
+          )
+        );
+    });
+  });
+}
+
+// src/declaration.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { lstat as lstat2, open, readFile as readFile2, rename, rm } from "node:fs/promises";
+import path2 from "node:path";
+import { parse, stringify } from "smol-toml";
+
+// src/contracts.ts
+import { Ajv2020 } from "ajv/dist/2020.js";
+
+// src/generated/contracts.ts
+var piAgentSchema = {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://contracts.tonbo.dev/agents/pi-agent-v1.schema.json",
+  "title": "PI Agent v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "runtime",
+    "driver"
+  ],
+  "properties": {
+    "runtime": {
+      "const": "pi"
+    },
+    "secrets": {
+      "type": "array",
+      "maxItems": 32,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^[A-Z_][A-Z0-9_]{0,127}$"
+      }
+    },
+    "driver": {
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "kind"
+          ],
+          "properties": {
+            "kind": {
+              "const": "native"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "kind",
+            "protocol",
+            "command"
+          ],
+          "properties": {
+            "kind": {
+              "const": "command"
+            },
+            "protocol": {
+              "const": "pi-rpc-v1"
+            },
+            "command": {
+              "type": "array",
+              "minItems": 1,
+              "maxItems": 64,
+              "items": {
+                "type": "string",
+                "minLength": 1,
+                "maxLength": 1024
+              }
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+var projectServiceSchema = {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://contracts.tonbo.dev/agents/project-service-v1.schema.json",
+  "title": "Tonbo Project application service v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "command"
+  ],
+  "properties": {
+    "command": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 64,
+      "items": {
+        "type": "string",
+        "minLength": 1,
+        "maxLength": 4096
+      }
+    },
+    "secrets": {
+      "type": "array",
+      "maxItems": 32,
+      "uniqueItems": true,
+      "items": {
+        "type": "string",
+        "pattern": "^[A-Z_][A-Z0-9_]{0,127}$"
+      }
+    },
+    "kubernetes": {
+      "$ref": "https://contracts.tonbo.dev/agents/kubernetes-profiles-v1.schema.json#/$defs/request"
+    }
+  }
+};
+var kubernetesProfilesSchema = {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://contracts.tonbo.dev/agents/kubernetes-profiles-v1.schema.json",
+  "title": "Tonbo managed Kubernetes profiles v1",
+  "$defs": {
+    "request": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "profile"
+      ],
+      "properties": {
+        "profile": false
+      }
+    }
+  },
+  "x-tonbo-profiles": {}
+};
+var declarationSchema = {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://contracts.tonbo.dev/agents/tonbo-declaration-v1.schema.json",
+  "title": "Tonbo Project Agent declaration v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "version",
+    "agent"
+  ],
+  "properties": {
+    "version": {
+      "const": 1
+    },
+    "agent": {
+      "$ref": "https://contracts.tonbo.dev/agents/pi-agent-v1.schema.json"
+    },
+    "inference": {
+      "type": "object",
+      "additionalProperties": false,
+      "default": {
+        "model": "claude-sonnet-4-5"
+      },
+      "required": [
+        "model"
+      ],
+      "properties": {
+        "model": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 160
+        }
+      }
+    },
+    "build": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "command"
+      ],
+      "properties": {
+        "command": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 64,
+          "items": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 1024
+          }
+        }
+      }
+    },
+    "service": {
+      "$ref": "https://contracts.tonbo.dev/agents/project-service-v1.schema.json"
+    }
+  }
+};
+var revisionSchema = {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://contracts.tonbo.dev/agents/managed-revision-v1.schema.json",
+  "title": "Managed Project revision v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "version",
+    "agent",
+    "source",
+    "inference"
+  ],
+  "properties": {
+    "version": {
+      "const": 1
+    },
+    "agent": {
+      "$ref": "https://contracts.tonbo.dev/agents/pi-agent-v1.schema.json"
+    },
+    "source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "format",
+        "sha256",
+        "size_bytes"
+      ],
+      "properties": {
+        "format": {
+          "const": "tar-v1"
+        },
+        "sha256": {
+          "type": "string",
+          "pattern": "^[0-9a-f]{64}$"
+        },
+        "size_bytes": {
+          "type": "integer",
+          "minimum": 1,
+          "maximum": 67108864
+        }
+      }
+    },
+    "inference": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "model"
+      ],
+      "properties": {
+        "model": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 160
+        }
+      }
+    },
+    "service": {
+      "$ref": "https://contracts.tonbo.dev/agents/project-service-v1.schema.json"
+    }
+  }
+};
+var sourceBundleContract = {
+  "version": 1,
+  "format": "tar-v1",
+  "bucket": "agent-source-bundles",
+  "content_type": "application/vnd.tonbo.source+tar",
+  "max_bytes": 67108864
+};
+var piSessionContract = {
+  "version": 1,
+  "adapter": "pi-jsonl-v3",
+  "format_version": 3,
+  "durable_completion_timeout_seconds": 30,
+  "session_directory": "/sessions",
+  "path_template": "/sessions/{session_id}.jsonl",
+  "preflight_command": [
+    "/usr/local/bin/artifacts",
+    "runtime",
+    "session-preflight"
+  ]
+};
+
+// src/contracts.ts
+var ajv = new Ajv2020({ allErrors: true, useDefaults: true });
+ajv.addKeyword({ keyword: "x-tonbo-profiles" });
+ajv.addSchema(kubernetesProfilesSchema);
+ajv.addSchema(piAgentSchema);
+ajv.addSchema(projectServiceSchema);
+var validateDeclaration = ajv.compile(declarationSchema);
+var validateRevision = ajv.compile(revisionSchema);
+function validationMessage(label, errors) {
+  const detail = errors?.map((error) => `${error.instancePath || "/"} ${error.message}`).join("; ");
+  return `${label} is invalid${detail ? `: ${detail}` : "."}`;
+}
+function parseDeclaration(value) {
+  const candidate = structuredClone(value);
+  if (!validateDeclaration(candidate)) {
+    throw new Error(validationMessage(".tonbo TOML", validateDeclaration.errors));
+  }
+  return candidate;
+}
+function assertManagedRevision(value) {
+  if (!validateRevision(value)) {
+    throw new Error(validationMessage("Managed revision", validateRevision.errors));
+  }
+}
+
+// src/declaration.ts
+var DECLARATION_FILENAME = ".tonbo";
+var DEFAULT_INFERENCE_MODEL = "claude-sonnet-4-5";
+function createDeclaration(model = DEFAULT_INFERENCE_MODEL, driver = { kind: "native" }, buildCommand) {
+  return parseDeclaration({
+    version: 1,
+    agent: { runtime: "pi", driver },
+    inference: { model: model.trim() },
+    ...buildCommand ? { build: { command: buildCommand } } : {}
+  });
+}
+function renderDeclaration(declaration) {
+  return `# Tonbo Project Agent configuration.
+${stringify(declaration)}`;
+}
+async function declarationExists(root) {
+  const filename = path2.join(root, DECLARATION_FILENAME);
+  try {
+    const metadata = await lstat2(filename);
+    if (metadata.isSymbolicLink() || !metadata.isFile())
+      throw new Error(`${filename} must be a regular file.`);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function saveDeclaration(root, declaration, overwrite) {
+  const filename = path2.join(root, DECLARATION_FILENAME);
+  const exists = await declarationExists(root);
+  if (exists && !overwrite)
+    throw new Error(`${DECLARATION_FILENAME} already exists. Pass --force to replace it.`);
+  const contents = renderDeclaration(declaration);
+  if (!overwrite) {
+    const handle2 = await open(filename, "wx", 420).catch((error) => {
+      if (error.code === "EEXIST")
+        throw new Error(`${DECLARATION_FILENAME} already exists. Pass --force to replace it.`);
+      throw error;
+    });
+    try {
+      await handle2.writeFile(contents, "utf8");
+      await handle2.sync();
+    } finally {
+      await handle2.close();
+    }
+    return;
+  }
+  const temporary = path2.join(root, `.${DECLARATION_FILENAME}.${process.pid}.${randomUUID2()}.tmp`);
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 420);
+    await handle.writeFile(contents, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename(temporary, filename);
+  } catch (error) {
+    await handle?.close().catch(() => void 0);
+    await rm(temporary, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+async function loadDeclaration(declarationRoot) {
+  const filename = path2.join(declarationRoot, DECLARATION_FILENAME);
+  let parsed;
+  try {
+    parsed = parse(await readFile2(filename, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT")
+      throw new Error(`No ${DECLARATION_FILENAME} declaration found at ${filename}.`);
+    throw new Error(`Could not read ${filename} as TOML.`, { cause: error });
+  }
+  return parseDeclaration(parsed);
+}
+function buildRevision(declaration, source) {
+  const spec = {
+    version: 1,
+    agent: declaration.agent,
+    source: {
+      format: source.format,
+      sha256: source.sha256,
+      size_bytes: source.size_bytes
+    },
+    inference: declaration.inference,
+    ...declaration.service ? { service: declaration.service } : {}
+  };
+  assertManagedRevision(spec);
+  return spec;
+}
+
+// src/source.ts
+import { createHash as createHash3 } from "node:crypto";
+import { lstat as lstat3, readFile as readFile3, readdir } from "node:fs/promises";
+import path3 from "node:path";
+import ignore from "ignore";
+import tar from "tar-stream";
+var MAX_BUNDLE_BYTES = sourceBundleContract.max_bytes;
+var SESSION_SOURCE_DIRECTORY = piSessionContract.session_directory.replace(/^\/+|\/+$/g, "");
+var DEFAULT_IGNORES = [
+  ".git/",
+  "node_modules/",
+  ".DS_Store",
+  ".env",
+  ".env.*",
+  "!.env.example",
+  ".tonbo-cache/",
+  ".tonbo-system/",
+  ".pi/npm/",
+  ".pi/git/"
+];
+var EXACT_NPM_VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var GIT_COMMIT = /^[0-9a-f]{40}$/i;
+function packageSource(value, index) {
+  if (typeof value === "string") return value;
+  if (value && typeof value === "object" && "source" in value && typeof value.source === "string")
+    return value.source;
+  throw new Error(`.pi/settings.json packages[${index}] must be a source string or object.`);
+}
+async function validatePackageSource(root, source) {
+  if (source.startsWith("npm:")) {
+    const specifier = source.slice(4);
+    const separator = specifier.lastIndexOf("@");
+    if (separator <= 0 || !EXACT_NPM_VERSION.test(specifier.slice(separator + 1))) {
+      throw new Error(
+        `PI package ${source} must pin an exact npm version, for example npm:my-agent@1.2.3.`
+      );
+    }
+    return;
+  }
+  if (source.startsWith("git:")) {
+    const separator = source.lastIndexOf("@");
+    if (separator <= "git:".length || !GIT_COMMIT.test(source.slice(separator + 1))) {
+      throw new Error(`PI package ${source} must pin a full 40-character Git commit.`);
+    }
+    return;
+  }
+  if (source.startsWith("./") || source.startsWith("../")) {
+    const settingsDirectory = path3.join(root, ".pi");
+    const resolved = path3.resolve(settingsDirectory, source);
+    const relative = path3.relative(root, resolved);
+    if (relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative)) {
+      throw new Error(`Local PI package ${source} resolves outside the deployed project.`);
+    }
+    let metadata;
+    try {
+      metadata = await lstat3(resolved);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Local PI package ${source} does not exist.`);
+      }
+      throw error;
+    }
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+      throw new Error(`Local PI package ${source} must resolve to a real project directory.`);
+    }
+    return;
+  }
+  throw new Error(
+    `PI package ${source} must use an exact npm version, a full Git commit, or a project-local path.`
+  );
+}
+async function validatePiPackages(root) {
+  const filename = path3.join(root, ".pi", "settings.json");
+  let settings;
+  try {
+    settings = JSON.parse(await readFile3(filename, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw new Error(`Could not read ${filename} as JSON.`, { cause: error });
+  }
+  if (!settings || typeof settings !== "object" || !("packages" in settings)) return;
+  const packages = settings.packages;
+  if (!Array.isArray(packages)) throw new Error(`${filename} packages must be an array.`);
+  await Promise.all(
+    packages.map((value, index) => validatePackageSource(root, packageSource(value, index)))
+  );
+}
+async function findDeclarationRoot(start) {
+  let candidate = path3.resolve(start);
+  for (; ; ) {
+    try {
+      if ((await lstat3(path3.join(candidate, ".tonbo"))).isFile()) return candidate;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const parent = path3.dirname(candidate);
+    if (parent === candidate) {
+      throw new Error(`No .tonbo declaration found above ${path3.resolve(start)}.`);
+    }
+    candidate = parent;
+  }
+}
+async function sourceIgnore(root) {
+  const matcher = ignore().add(DEFAULT_IGNORES);
+  try {
+    matcher.add(await readFile3(path3.join(root, ".tonboignore"), "utf8"));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return matcher;
+}
+async function collectFiles(root) {
+  const matcher = await sourceIgnore(root);
+  const files = [];
+  async function visit(directory, relativeDirectory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((left, right) => left.name.localeCompare(right.name, "en"));
+    for (const entry of entries) {
+      const relative = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
+      const ignored = matcher.ignores(relative + (entry.isDirectory() ? "/" : ""));
+      if (ignored) continue;
+      if (relative === SESSION_SOURCE_DIRECTORY || relative.startsWith(`${SESSION_SOURCE_DIRECTORY}/`)) {
+        throw new Error(
+          `Source path ${SESSION_SOURCE_DIRECTORY}/ is reserved for durable PI history. Rename it or exclude it with .tonboignore.`
+        );
+      }
+      const absolute = path3.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        await visit(absolute, relative);
+        continue;
+      }
+      const metadata = await lstat3(absolute);
+      if (!metadata.isFile()) {
+        throw new Error(
+          `Source path ${relative} is not a regular file. V1 does not follow symlinks or special files.`
+        );
+      }
+      files.push({
+        absolute,
+        mode: metadata.mode & 73 ? 493 : 420,
+        relative,
+        size: metadata.size
+      });
+    }
+  }
+  await visit(root, "");
+  if (!files.some((file) => file.relative === ".tonbo")) {
+    throw new Error("The source bundle must contain .tonbo.");
+  }
+  return files;
+}
+function addEntry(pack, file, contents) {
+  return new Promise((resolve, reject) => {
+    pack.entry(
+      {
+        gid: 0,
+        mode: file.mode,
+        mtime: /* @__PURE__ */ new Date(0),
+        name: file.relative,
+        size: contents.length,
+        type: "file",
+        uid: 0
+      },
+      contents,
+      (error) => error ? reject(error) : resolve()
+    );
+  });
+}
+async function buildSourceBundle(root) {
+  const resolvedRoot = path3.resolve(root);
+  await validatePiPackages(resolvedRoot);
+  const files = await collectFiles(resolvedRoot);
+  const payloadBytes = files.reduce((total, file) => total + file.size, 0);
+  if (payloadBytes > MAX_BUNDLE_BYTES) {
+    throw new Error(`Source files exceed ${MAX_BUNDLE_BYTES} bytes after ignore rules.`);
+  }
+  const pack = tar.pack();
+  const chunks = [];
+  let size = 0;
+  pack.on("data", (chunk) => {
+    size += chunk.length;
+    if (size > MAX_BUNDLE_BYTES) {
+      pack.destroy(
+        new Error(`Source bundle exceeds ${MAX_BUNDLE_BYTES} bytes after ignore rules.`)
+      );
+      return;
+    }
+    chunks.push(chunk);
+  });
+  const completed = new Promise((resolve, reject) => {
+    pack.on("end", resolve);
+    pack.on("error", reject);
+  });
+  for (const file of files) {
+    await addEntry(pack, file, await readFile3(file.absolute));
+  }
+  pack.finalize();
+  await completed;
+  const bytes = Buffer.concat(chunks);
+  return {
+    bytes,
+    format: sourceBundleContract.format,
+    root: resolvedRoot,
+    sha256: createHash3("sha256").update(bytes).digest("hex"),
+    size_bytes: bytes.length
+  };
+}
+
+// src/ssh-key.ts
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile4 } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+var DEFAULT_PUBLIC_KEYS = ["id_ed25519.pub", "id_ecdsa.pub", "id_rsa.pub"];
+var ALGORITHMS = /* @__PURE__ */ new Set(["ssh-ed25519", "ecdsa-sha2-nistp256", "ssh-rsa"]);
+function parseOpenSshPublicKey(value, label) {
+  const fields = value.trim().split(/\s+/);
+  if (fields.length < 2 || !ALGORITHMS.has(fields[0]))
+    throw new Error("SSH public key must be Ed25519, ECDSA P-256, or RSA.");
+  const blob = Buffer.from(fields[1], "base64");
+  if (blob.length < 32 || blob.length > 16384 || blob.toString("base64") !== fields[1])
+    throw new Error("SSH public key is not canonical base64.");
+  return {
+    algorithm: fields[0],
+    fingerprint: `SHA256:${createHash4("sha256").update(blob).digest("base64").replace(/=$/, "")}`,
+    keyBase64: fields[1],
+    label
+  };
+}
+async function readSshPublicKey(path7) {
+  return parseOpenSshPublicKey(await readFile4(path7, "utf8"), basename(path7, ".pub"));
+}
+async function readDefaultSshPublicKeys(sshDirectory = join(homedir(), ".ssh")) {
+  const keys = [];
+  for (const name of DEFAULT_PUBLIC_KEYS) {
+    const key = await readSshPublicKey(join(sshDirectory, name)).catch(
+      (error) => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      }
+    );
+    if (key) keys.push(key);
+  }
+  return keys;
+}
+
+// src/ssh.ts
+import { spawn as spawn2 } from "node:child_process";
+var PROJECT_SSH_HOST = "tonbo.sh";
+function projectSshDestination(projectSlug) {
+  return `${projectSlug}@${PROJECT_SSH_HOST}`;
+}
+async function launchProjectSsh(projectSlug) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2("ssh", [projectSshDestination(projectSlug)], {
+      stdio: "inherit"
+    });
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      if (signal) reject(new Error(`ssh was terminated by ${signal}`));
+      else resolve(code ?? 1);
+    });
+  });
+}
+
+// src/commands.ts
+async function resolveProject(deps, selector) {
+  const oauthToken = await deps.auth.accessToken();
+  if (selector) {
+    const normalized = selector.endsWith(".tonbo.sh") ? selector.slice(0, -".tonbo.sh".length) : selector;
+    return {
+      oauthToken,
+      project: selectProject(await deps.api.listProjects(oauthToken), normalized)
+    };
+  }
+  const root = await findDeclarationRoot(deps.cwd());
+  const binding = await deps.config.getBinding(root);
+  if (!binding) throw new Error("No Project selected. Run `tonbo project use <project>` first.");
+  return {
+    oauthToken,
+    project: {
+      id: binding.projectId,
+      slug: binding.projectSlug,
+      status: "active"
+    }
+  };
+}
+function selectProject(projects, selector) {
+  const matches = projects.filter(
+    (project) => project.id === selector || project.slug === selector
+  );
+  if (matches.length === 0) throw new Error(`Project ${selector} was not found in your account.`);
+  if (matches.length > 1) throw new Error(`Project slug ${selector} is ambiguous; use its ID.`);
+  if (matches[0].status !== "active") throw new Error(`Project ${selector} is not active.`);
+  return matches[0];
+}
+async function initCommand(deps, options) {
+  const root = deps.cwd();
+  const exists = await declarationExists(root);
+  let overwrite = options.force === true;
+  if (exists && !overwrite) {
+    if (!deps.interactive())
+      throw new Error(`${DECLARATION_FILENAME} already exists. Pass --force to replace it.`);
+    const answer = (await deps.prompt(`Replace existing ${DECLARATION_FILENAME}? [y/N] `)).trim().toLowerCase();
+    if (answer !== "y" && answer !== "yes") {
+      deps.output({ message: `Kept existing ${DECLARATION_FILENAME}.` });
+      return;
+    }
+    overwrite = true;
+  }
+  const inspection = await deps.inspectSource(root);
+  let harness = options.harness;
+  if (harness !== void 0 && harness !== "pi") {
+    throw new Error("--harness must name a supported Harness: pi.");
+  }
+  let driver = options.driver;
+  if (driver !== void 0 && driver !== "native" && driver !== "command") {
+    throw new Error("--driver must be native or command.");
+  }
+  if (!harness && !driver && deps.interactive() && inspection.harness.state === "selection_required") {
+    const target = await deps.select("How should Tonbo run this project?", piTargetChoices(false));
+    harness = "pi";
+    driver = target;
+  }
+  if (!harness) {
+    if (inspection.harness.state === "identified") harness = inspection.harness.id;
+    else if (!deps.interactive()) {
+      throw new Error("No Harness-specific configuration found. Pass --harness pi.");
+    } else {
+      harness = await deps.select("Which supported Harness should Tonbo use?", [
+        {
+          description: "Run this project with the pi command.",
+          name: "PI (`pi`)",
+          value: "pi"
+        }
+      ]);
+    }
+  }
+  if (harness !== "pi") throw new Error(`Harness ${harness} is not supported.`);
+  if (!driver) {
+    if (!deps.interactive()) {
+      throw new Error("PI execution mode is required. Pass --driver native or --driver command.");
+    }
+    if (inspection.pi.settingsFound) {
+      const packageSummary = inspection.pi.packageCount === 0 ? "Found PI configuration at .pi/settings.json." : `Found PI configuration at .pi/settings.json with ${inspection.pi.packageCount} package${inspection.pi.packageCount === 1 ? "" : "s"}.`;
+      deps.output({ message: packageSummary });
+    }
+    driver = await deps.select(
+      "How should Tonbo start PI?",
+      piTargetChoices(inspection.pi.settingsFound)
+    );
+  }
+  if (driver === "native" && (options.agentEntry || options.buildCommand)) {
+    throw new Error("--agent-entry and --build-command require --driver command.");
+  }
+  let entry = options.agentEntry?.trim();
+  if (driver === "command" && !entry && deps.interactive()) {
+    entry = (await deps.prompt("PI SDK entry file [dist/agent.mjs]: ")).trim();
+  }
+  entry ||= "dist/agent.mjs";
+  const model = options.model?.trim() || DEFAULT_INFERENCE_MODEL;
+  const buildCommand = driver === "command" ? options.buildCommand ?? ["npm", "run", "build"] : void 0;
+  const declaration = createDeclaration(
+    model,
+    driver === "native" ? { kind: "native" } : { kind: "command", protocol: "pi-rpc-v1", command: ["node", entry] },
+    buildCommand
+  );
+  await saveDeclaration(root, declaration, overwrite);
+  const driverSummary = driver === "command" ? `PI SDK app
+Build: ${buildCommand?.join(" ")}
+Entrypoint: node ${entry}` : inspection.pi.packageCount > 0 ? `PI CLI with ${inspection.pi.packageCount} package${inspection.pi.packageCount === 1 ? "" : "s"}` : "PI CLI";
+  deps.output({
+    message: `${exists ? "Updated" : "Created"} ${DECLARATION_FILENAME}.
+Harness: PI
+Mode: ${driverSummary}
+Next: tonbo project create <slug>`,
+    declaration,
+    path: path4.join(root, DECLARATION_FILENAME)
+  });
+}
+function piTargetChoices(settingsFound) {
+  const choices = {
+    command: {
+      description: "Run a custom Node.js entrypoint built on the PI SDK.",
+      name: "PI SDK app",
+      value: "command"
+    },
+    native: {
+      description: settingsFound ? "Run pi directly and load the detected project-local PI configuration." : "Run pi directly with AGENTS.md and optional project-local .pi resources.",
+      name: "PI CLI (`pi`)",
+      value: "native"
+    }
+  };
+  return supportedExecutionTargets.filter((target) => target.harness === "pi").map((target) => choices[target.driver]);
+}
+async function loginCommand(deps) {
+  try {
+    const tokens = await deps.auth.login((event) => reportLoginProgress(deps.progress, event));
+    deps.progress.start("Preparing SSH access");
+    const keys = await deps.defaultSshPublicKeys();
+    await Promise.all(keys.map((key) => deps.api.registerSshKey(tokens.access_token, key)));
+    deps.progress.succeed("SSH access ready");
+    deps.output({ message: "Logged in to Tonbo." });
+  } catch (error) {
+    deps.progress.fail();
+    throw error;
+  }
+}
+var LOGIN_PROGRESS_MESSAGES = {
+  "account-config": {
+    started: "Connecting to Tonbo",
+    completed: "Connected to Tonbo"
+  },
+  "callback-server": {
+    started: "Starting local browser callback",
+    completed: "Local browser callback ready"
+  },
+  browser: {
+    started: "Opening browser",
+    completed: "Browser opened"
+  },
+  "browser-authorization": {
+    started: "Waiting for browser authorization",
+    completed: "Browser authorization received"
+  },
+  "callback-close": {
+    started: "Closing local browser callback",
+    completed: "Local browser callback closed"
+  },
+  "token-exchange": {
+    started: "Exchanging authorization code",
+    completed: "Authorization code exchanged"
+  },
+  "credential-store": {
+    started: "Saving login session",
+    completed: "Login session saved"
+  }
+};
+function reportLoginProgress(progress, event) {
+  const messages = LOGIN_PROGRESS_MESSAGES[event.step];
+  if (event.status === "started") progress.start(messages.started);
+  else progress.succeed(messages.completed);
+}
+async function sshKeyAddCommand(deps, path7) {
+  const key = await readSshPublicKey(path7);
+  const oauthToken = await deps.auth.accessToken();
+  await deps.api.registerSshKey(oauthToken, key);
+  deps.output({ message: `Registered SSH key ${key.fingerprint}.`, key });
+}
+async function sshKeyRemoveCommand(deps, fingerprint) {
+  const oauthToken = await deps.auth.accessToken();
+  const key = await deps.api.revokeSshKey(oauthToken, fingerprint);
+  deps.output({ message: `Revoked SSH key ${key.fingerprint}.`, key });
+}
+async function projectUseCommand(deps, selector) {
+  const root = await findDeclarationRoot(deps.cwd());
+  const oauthToken = await deps.auth.accessToken();
+  const project = selectProject(await deps.api.listProjects(oauthToken), selector);
+  await deps.config.setBinding(root, {
+    projectId: project.id,
+    projectSlug: project.slug
+  });
+  deps.output({ message: `Using Project ${project.slug}.`, project });
+}
+async function projectCreateCommand(deps, slug, name) {
+  const root = await findDeclarationRoot(deps.cwd());
+  const oauthToken = await deps.auth.accessToken();
+  const project = await deps.api.createProject(oauthToken, slug, name);
+  await deps.config.setBinding(root, {
+    projectId: project.id,
+    projectSlug: project.slug
+  });
+  deps.output({ message: `Created and selected Project ${project.slug}.`, project });
+}
+async function deployCommand(deps, selector) {
+  const root = await findDeclarationRoot(deps.cwd());
+  const declaration = await loadDeclaration(root);
+  if (declaration.build) await runBuildCommand(root, declaration.build.command);
+  const source = await buildSourceBundle(root);
+  const oauthToken = await deps.auth.accessToken();
+  let binding = await deps.config.getBinding(root);
+  if (selector) {
+    const project = selectProject(await deps.api.listProjects(oauthToken), selector);
+    binding = { projectId: project.id, projectSlug: project.slug };
+  }
+  if (!binding) throw new Error("No Project selected. Run `tonbo project use <project>` first.");
+  const managementToken = await deps.api.exchangeManagementToken(oauthToken, binding.projectId);
+  const result = await deps.api.deploy({
+    bundle: source,
+    projectId: binding.projectId,
+    spec: buildRevision(declaration, source),
+    token: managementToken
+  });
+  deps.output({
+    message: `Deployed Project ${binding.projectSlug}.`,
+    project: binding,
+    ...result
+  });
+}
+async function runCommand(deps, prompt, options) {
+  const root = await findDeclarationRoot(deps.cwd());
+  const oauthToken = await deps.auth.accessToken();
+  let binding = await deps.config.getBinding(root);
+  if (options.project) {
+    const project = selectProject(await deps.api.listProjects(oauthToken), options.project);
+    binding = { projectId: project.id, projectSlug: project.slug };
+  }
+  if (!binding) throw new Error("No Project selected. Run `tonbo project use <project>` first.");
+  const managementToken = await deps.api.exchangeManagementToken(oauthToken, binding.projectId);
+  const result = await deps.api.run({
+    projectId: binding.projectId,
+    prompt,
+    sessionId: options.session,
+    token: managementToken
+  });
+  deps.output({
+    message: result.turn.assistant_text,
+    project: binding,
+    ...result
+  });
+}
+async function sshCommand(deps, selector) {
+  const { project } = await resolveProject(deps, selector);
+  const code = await launchProjectSsh(project.slug);
+  if (code !== 0) throw new Error(`ssh exited with status ${code}`);
+}
+async function projectManagement(deps, selector) {
+  const { oauthToken, project } = await resolveProject(deps, selector);
+  return {
+    project,
+    token: await deps.api.exchangeManagementToken(oauthToken, project.id)
+  };
+}
+async function secretListCommand(deps, selector) {
+  const { project, token } = await projectManagement(deps, selector);
+  const secrets = await deps.api.listProjectSecrets(project.id, token);
+  deps.output({
+    message: secrets.length ? secrets.map((secret) => secret.name).join("\n") : "No Project secrets are configured.",
+    project,
+    secrets
+  });
+}
+async function secretSetCommand(deps, name, options) {
+  const value = await deps.secretValue(name, options.fromEnv);
+  const { project, token } = await projectManagement(deps, options.project);
+  const secret = await deps.api.setProjectSecret(project.id, name, value, token);
+  deps.output({
+    message: `Set Project secret ${secret.name}. Redeploy to replace the active runtime with this value.`,
+    project,
+    secret
+  });
+}
+async function secretRemoveCommand(deps, name, selector) {
+  const { project, token } = await projectManagement(deps, selector);
+  await deps.api.deleteProjectSecret(project.id, name, token);
+  deps.output({ message: `Removed Project secret ${name}.`, project, name });
+}
+
+// src/config.ts
+import { mkdir, readFile as readFile5, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path5 from "node:path";
+var FileConfigStore = class {
+  constructor(filename = defaultConfigPath()) {
+    this.filename = filename;
+  }
+  async getBinding(declarationRoot) {
+    const config = await this.read();
+    return config.bindings[path5.resolve(declarationRoot)] ?? null;
+  }
+  async setBinding(declarationRoot, binding) {
+    const config = await this.read();
+    config.bindings[path5.resolve(declarationRoot)] = binding;
+    await mkdir(path5.dirname(this.filename), { recursive: true, mode: 448 });
+    await writeFile(this.filename, `${JSON.stringify(config, null, 2)}
+`, {
+      mode: 384
+    });
+  }
+  async read() {
+    try {
+      const value = JSON.parse(await readFile5(this.filename, "utf8"));
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error();
+      const bindings = value.bindings;
+      if (!bindings || typeof bindings !== "object" || Array.isArray(bindings)) throw new Error();
+      return { bindings };
+    } catch (error) {
+      if (error.code === "ENOENT") return { bindings: {} };
+      throw new Error(`Could not read Tonbo config at ${this.filename}.`, {
+        cause: error
+      });
+    }
+  }
+};
+function defaultConfigPath() {
+  return path5.join(defaultConfigDirectory(), "config.json");
+}
+function defaultConfigDirectory() {
+  const base = process.env.XDG_CONFIG_HOME || path5.join(os.homedir(), ".config");
+  return path5.join(base, "tonbo");
+}
+
+// src/credentials.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { chmod, lstat as lstat4, mkdir as mkdir2, open as open2, readFile as readFile6, rename as rename2, rm as rm2 } from "node:fs/promises";
+import path6 from "node:path";
+var FileCredentialStore = class {
+  constructor(filename = path6.join(defaultConfigDirectory(), "credentials.json")) {
+    this.filename = filename;
+  }
+  async load() {
+    try {
+      await assertPrivateRegularFile(this.filename);
+      const parsed = JSON.parse(await readFile6(this.filename, "utf8"));
+      if (!isOAuthTokenSet(parsed)) throw new Error("invalid token set");
+      return parsed;
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw new Error(`Could not read Tonbo credentials at ${this.filename}.`, { cause: error });
+    }
+  }
+  async save(tokens) {
+    if (!isOAuthTokenSet(tokens)) throw new Error("Refusing to store a malformed Tonbo token set.");
+    const directory = path6.dirname(this.filename);
+    await mkdir2(directory, { mode: 448, recursive: true });
+    await preparePrivateDirectory(directory);
+    await assertExistingDestinationIsSafe(this.filename);
+    const temporary = path6.join(
+      directory,
+      `.${path6.basename(this.filename)}.${process.pid}.${randomUUID3()}.tmp`
+    );
+    let handle = null;
+    try {
+      handle = await open2(temporary, "wx", 384);
+      await handle.writeFile(`${JSON.stringify(tokens, null, 2)}
+`, "utf8");
+      await handle.sync();
+      await handle.close();
+      handle = null;
+      if (process.platform !== "win32") await chmod(temporary, 384);
+      await rename2(temporary, this.filename);
+    } catch (error) {
+      await handle?.close().catch(() => void 0);
+      await rm2(temporary, { force: true }).catch(() => void 0);
+      throw new Error(`Could not store Tonbo credentials at ${this.filename}.`, { cause: error });
+    }
+  }
+};
+function isOAuthTokenSet(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const token = value;
+  return typeof token.access_token === "string" && token.access_token.length > 0 && (token.refresh_token === void 0 || typeof token.refresh_token === "string") && (token.expires_at === void 0 || Number.isInteger(token.expires_at) && (token.expires_at ?? 0) > 0);
+}
+async function preparePrivateDirectory(directory) {
+  const stat = await lstat4(directory);
+  if (stat.isSymbolicLink() || !stat.isDirectory())
+    throw new Error("Tonbo config directory must be a real directory.");
+  if (process.platform !== "win32") await chmod(directory, 448);
+}
+async function assertExistingDestinationIsSafe(filename) {
+  try {
+    const stat = await lstat4(filename);
+    if (stat.isSymbolicLink() || !stat.isFile())
+      throw new Error("Tonbo credential path must be a regular file.");
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function assertPrivateRegularFile(filename) {
+  const stat = await lstat4(filename);
+  if (stat.isSymbolicLink() || !stat.isFile())
+    throw new Error("Tonbo credential path must be a regular file.");
+  if (process.platform !== "win32" && (stat.mode & 63) !== 0)
+    throw new Error("Tonbo credential file must have mode 0600.");
+}
+
+// src/progress.ts
+var FRAMES = ["|", "/", "-", "\\"];
+var TerminalProgress = class {
+  constructor(stream, intervalMs = 80) {
+    this.stream = stream;
+    this.intervalMs = intervalMs;
+  }
+  activeMessage;
+  frame = 0;
+  lastWidth = 0;
+  timer;
+  start(message) {
+    if (this.activeMessage) this.succeed();
+    this.activeMessage = message;
+    this.frame = 0;
+    if (!this.stream.isTTY) {
+      this.stream.write(`[..] ${message}
+`);
+      return;
+    }
+    this.render(`[${FRAMES[this.frame]}] ${message}`);
+    this.timer = setInterval(() => {
+      this.frame = (this.frame + 1) % FRAMES.length;
+      this.render(`[${FRAMES[this.frame]}] ${this.activeMessage}`);
+    }, this.intervalMs);
+    this.timer.unref();
+  }
+  succeed(message = this.activeMessage) {
+    this.finish("ok", message);
+  }
+  fail(message = this.activeMessage) {
+    this.finish("!!", message);
+  }
+  finish(marker, message) {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.activeMessage = void 0;
+    if (!message) return;
+    const line = `[${marker}] ${message}`;
+    if (this.stream.isTTY) {
+      this.render(line);
+      this.stream.write("\n");
+      this.lastWidth = 0;
+      return;
+    }
+    this.stream.write(`${line}
+`);
+  }
+  render(value) {
+    this.stream.write(`\r${value.padEnd(this.lastWidth)}`);
+    this.lastWidth = value.length;
+  }
+};
+var silentProgress = {
+  start: () => {
+  },
+  succeed: () => {
+  },
+  fail: () => {
+  }
+};
+
+// src/prompt.ts
+import select from "@inquirer/select";
+import { createInterface } from "node:readline/promises";
+async function terminalPrompt(question) {
+  const prompt = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    return await prompt.question(`? ${question}`);
+  } finally {
+    prompt.close();
+  }
+}
+async function terminalSelect(question, choices) {
+  return select(
+    {
+      choices,
+      message: question,
+      pageSize: choices.length
+    },
+    {
+      input: process.stdin,
+      output: process.stderr
+    }
+  );
+}
+
+// src/app.ts
+var packageVersion = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url), "utf8")
+);
+function createDependencies(json = false) {
+  const accountOrigin = process.env.TONBO_ACCOUNT_ORIGIN || "https://tonbo.dev";
+  const managementOrigin = process.env.TONBO_API_ORIGIN || "https://api.tonbo.dev";
+  return {
+    api: new TonboApi(fetch, accountOrigin, managementOrigin),
+    auth: new AuthClient(new FileCredentialStore(), fetch, accountOrigin),
+    config: new FileConfigStore(),
+    cwd: () => process.cwd(),
+    defaultSshPublicKeys: readDefaultSshPublicKeys,
+    interactive: () => !json && process.stdin.isTTY === true && process.stderr.isTTY === true,
+    inspectSource: inspectLocalAgentSource,
+    output: (value) => {
+      if (json) console.log(JSON.stringify(value));
+      else console.log(value.message ?? value);
+    },
+    progress: json ? silentProgress : new TerminalProgress(process.stderr),
+    prompt: terminalPrompt,
+    select: terminalSelect,
+    secretValue: async (name, fromEnvironment) => {
+      const environmentName = fromEnvironment ?? name;
+      const value = process.env[environmentName];
+      if (!value)
+        throw new Error(
+          `Environment variable ${environmentName} is empty. Set it before running tonbo secret set.`
+        );
+      return value;
+    }
+  };
+}
+function createProgram(dependencies = createDependencies) {
+  const program = new Command().name("tonbo").description("Deploy a persistent Project Agent to Tonbo.").version(packageVersion.version).option("--json", "print machine-readable JSON");
+  program.command("init").description("interactively create a Tonbo Agent declaration in this directory").option("--harness <harness>", "Agent Harness (currently pi)").option("--model <model>", "inference model").option("--driver <driver>", "PI driver: native or command").option("--agent-entry <file>", "Node entry file for the command driver").option("--build-command <argv...>", "build command argv for the command driver").option("--force", `replace an existing ${DECLARATION_FILENAME}`).action(
+    async (options) => initCommand(dependencies(program.opts().json), options)
+  );
+  program.command("login").description("sign in through the browser and store the session in the user config").action(async () => loginCommand(dependencies(program.opts().json)));
+  const project = program.command("project").description("manage the Project bound to this Agent directory");
+  project.command("create <slug>").description("create and bind a Project to this Agent directory").option("--name <name>", "display name for the Project").action(
+    async (slug, options) => projectCreateCommand(dependencies(program.opts().json), slug, options.name)
+  );
+  const sshKey = program.command("ssh-key").description("manage public keys used by native Project SSH");
+  sshKey.command("add <public-key>").description("register an OpenSSH public key with the current Tonbo account").action(async (path7) => sshKeyAddCommand(dependencies(program.opts().json), path7));
+  sshKey.command("remove <fingerprint>").description("revoke an SSH public key from the current Tonbo account").action(
+    async (fingerprint) => sshKeyRemoveCommand(dependencies(program.opts().json), fingerprint)
+  );
+  project.command("use <project>").description("bind this .tonbo directory to a Project slug or ID").action(
+    async (selector) => projectUseCommand(dependencies(program.opts().json), selector)
+  );
+  program.command("deploy").description("upload this directory as the selected Project deployment").option("--project <project>", "override the bound Project for this deploy").action(
+    async (options) => deployCommand(dependencies(program.opts().json), options.project)
+  );
+  program.command("run <prompt>").description("run one prompt in a durable Project session").option("--project <project>", "override the bound Project for this turn").option("--session <session>", "resume an existing Agent Session UUID").action(
+    async (prompt, options) => runCommand(dependencies(program.opts().json), prompt, options)
+  );
+  program.command("ssh").description("open the selected Project's singleton runtime over SSH").option("--project <project>", "override the bound Project").action(
+    async (options) => sshCommand(dependencies(program.opts().json), options.project)
+  );
+  const secret = program.command("secret").description("manage encrypted environment secrets for the Project service");
+  secret.command("list").option("--project <project>", "override the bound Project").action(
+    async (options) => secretListCommand(dependencies(program.opts().json), options.project)
+  );
+  secret.command("set <name>").description("set a secret from an environment variable (the same name by default)").option("--from-env <name>", "read the value from another environment variable").option("--project <project>", "override the bound Project").action(
+    async (name, options) => secretSetCommand(dependencies(program.opts().json), name, options)
+  );
+  secret.command("remove <name>").option("--project <project>", "override the bound Project").action(
+    async (name, options) => secretRemoveCommand(dependencies(program.opts().json), name, options.project)
+  );
+  return program;
+}
+
+// src/main.ts
+try {
+  await createProgram().parseAsync(process.argv);
+} catch (error) {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+}