toolroll 0.9.62 → 0.9.65

package/dist/integrations-ui.d.ts

@@ -5,10 +5,11 @@
  * render never waits on one (see integrations.ts).
  */
 import { type Html } from "./html.js";
-import { type Integration } from "./integrations.js";
+import { type Integration, type SecretsKept } from "./integrations.js";
 export declare const INTEGRATIONS_CSS: string;
 export declare function integrationsHtml(list: readonly Integration[], csrf: string, notice: {
     said?: string | null;
     problem?: string | null;
     checking?: boolean;
+    secrets?: SecretsKept;
 }): Html;

package/dist/integrations-ui.js

@@ -5,7 +5,7 @@
  * render never waits on one (see integrations.ts).
  */
 import { html, joinHtml, postForm } from "./html.js";
-import { STATE_WORDS } from "./integrations.js";
+import { STATE_WORDS, secretsNote } from "./integrations.js";
 import { whenUtc } from "./when-html.js";
 import { brandMarkHtml } from "./brand-mark.js";
 const when = (at) => whenUtc(at);
@@ -49,7 +49,7 @@ function row(one, csrf) {
     const badge = !one.checked && one.state === "connected"
         ? html `<span class="integration-state integration-state--checking"><i aria-hidden="true"></i>Checking</span>`
         : html `<span class="integration-state integration-state--${one.state}"><i aria-hidden="true"></i>${STATE_WORDS[one.state]}</span>`;
-    const facts = [one.account, one.detail].filter(Boolean).join(" · ");
+    const facts = [one.account, one.detail, one.credentials].filter(Boolean).join(" · ");
     const command = one.action.kind !== "test" ? one.action.command : null;
     const fix = one.action.kind === "fix" ? html `<p class="integration-fix" role="status">${one.action.words}</p>` : "";
     const run = command === null || (one.action.kind === "fix" && one.action.words.includes(command)) ? "" : html `<p class="meta">Run <code>${command}</code> on the computer running Toolroll.</p>`;
@@ -69,5 +69,8 @@ export function integrationsHtml(list, csrf, notice) {
         const rows = list.filter(one => one.group === group);
         return rows.length === 0 ? "" : html `<h2>${title}</h2>${rows.map(one => row(one, csrf))}`;
     });
-    return html `<section class="integrations">${note}${summary}${sections}</section>`;
+    // No keychain here, or Toolroll's folder for secrets can't be used: said once, plainly.
+    const said = secretsNote(list, notice.secrets);
+    const kept = said === null ? "" : said.problem ? html `<p class="problem integration-secrets" role="alert">${said.words}</p>` : html `<p class="meta integration-secrets" role="note">${said.words}</p>`;
+    return html `<section class="integrations">${note}${summary}${kept}${sections}</section>`;
 }

package/dist/integrations.d.ts

@@ -38,6 +38,8 @@ export type Integration = {
     action: IntegrationAction;
     /** A project's own MCP tool: it shows a letter, never a logo matched by name. */
     custom?: true;
+    /** A project's MCP tool: how its runs get credentials ("Short-lived token per run", "Key held by Toolroll"). */
+    credentials?: string;
 };
 export declare const STATE_WORDS: Record<IntegrationState, string>;
 export type ProbeResult = {
@@ -69,7 +71,7 @@ export type IntegrationIo = {
     /** The same sign-in check Settings → AI providers makes. */
     checkConnection?: ConnectionChecker;
     /** Where project tool secrets live. */
-    toolHome?: string;
+    toolHome?: string | undefined;
     /** Whether a mail server answers at host:port (tests replace it). */
     reach?: (host: string, port: number, secure: boolean) => Promise<void>;
     clock?: () => Date;
@@ -97,8 +99,20 @@ export declare function integrationsNow(io: IntegrationIo): Integration[];
 export declare function checkIntegrations(io: IntegrationIo, keys?: readonly string[]): Promise<Integration[]>;
 /** The one line `status` and `onboard` add when something is Broken; null when nothing is. */
 export declare function integrationsBrokenLine(list: readonly Integration[]): string | null;
-/** The CLI's lines: one per integration, then the fix under anything Broken. */
-export declare function renderIntegrations(list: readonly Integration[]): string[];
+/** Where secrets rest (project-tools.ts toolSecretStorage), as Settings and the CLI take it. */
+export type SecretsKept = {
+    words: string;
+    filesOnly: boolean;
+    problem?: string;
+};
+/** The one line about where secrets rest, or null: a folder that can't be used always; files only once something set up holds secrets. */
+export declare function secretsNote(list: readonly Integration[], secrets: SecretsKept | null | undefined): {
+    words: string;
+    problem: boolean;
+} | null;
+/** The CLI's lines: one per integration, then the fix under anything Broken; last, where secrets are kept when that is
+ * files only, or why they can't be used (secretsNote). */
+export declare function renderIntegrations(list: readonly Integration[], secrets?: SecretsKept | null): string[];
 export type IntegrationMonitor = {
     /** The list now, without waiting; starts a background check when the last one is older than the cache. */
     list(): Integration[];

package/dist/integrations.js

@@ -17,7 +17,6 @@
  */
 import { connect as tcpConnect } from "node:net";
 import { connect as tlsConnect } from "node:tls";
-import { homedir } from "node:os";
 import { basename } from "node:path";
 import { ALL_CREDENTIAL_ENV } from "./provider.js";
 import { providerName, signInCommand } from "./provider-auth.js";
@@ -29,7 +28,7 @@ import { effectivePrimary } from "./webhooks.js";
 import { readEmailSettings } from "./email-settings.js";
 import { googleConnected } from "./google-mail.js";
 import { LINEAR_URL, readHooksBase, readLinearKey } from "./flow-triggers.js";
-import { projectToolsOf, readToolSecrets, missingSecrets, testToolOf } from "./project-tools.js";
+import { credentialModeOf, projectToolsOf, readToolSecrets, missingSecrets, secretsSetFor, testToolOf } from "./project-tools.js";
 import { origin, readMonitoring } from "./monitoring-settings.js";
 import { targetOf } from "./monitoring.js";
 export const STATE_WORDS = { connected: "Connected", "not-set-up": "Not set up", broken: "Broken" };
@@ -375,15 +374,23 @@ function targets(io) {
         probe: email === null ? null : check => probeEmail(check, { host: email.host, port: email.port, secure: email.secure }, email.imap),
     });
     // Each project's MCP tools: the server starts and lists its tools.
-    const toolHome = io.toolHome ?? homedir();
+    const toolHome = io.toolHome;
     let anyTool = false;
     for (const repo of io.repos) {
         for (const tool of projectToolsOf(store, repo)) {
             anyTool = true;
             const href = `/settings/tools?repo=${encodeURIComponent(repo)}#tool-${encodeURIComponent(tool.name)}`;
             const test = tool.lastTest;
+            // Which secrets are set, by name only: no value is read to say how runs get them.
+            let credentials;
+            try {
+                credentials = credentialModeOf(tool.spec, secretsSetFor(repo, tool.spec, toolHome))?.words;
+            }
+            catch {
+                credentials = undefined;
+            }
             list.push({
-                key: `mcp:${repo}:${tool.name}`, group: "tools", name: tool.name, configured: true, account: basename(repo), ...(tool.source === "custom" ? { custom: true } : {}),
+                key: `mcp:${repo}:${tool.name}`, group: "tools", name: tool.name, configured: true, account: basename(repo), ...(tool.source === "custom" ? { custom: true } : {}), ...(credentials === undefined ? {} : { credentials }),
                 setup: place(href), fix: place(href), usedBy: [`Tasks in ${basename(repo)}`],
                 activity: test === null ? NO_ACTIVITY : test.ok ? { okAt: test.at, error: null, errorAt: null, failing: false } : { okAt: null, error: test.problem, errorAt: test.at, failing: false },
                 probe: async (check) => {
@@ -432,7 +439,7 @@ function targets(io) {
 }
 // ---------------------------------------------------------------- the list
 function combine(target, row) {
-    const base = { key: target.key, group: target.group, name: target.name, usedBy: target.usedBy, ...(target.custom ? { custom: true } : {}) };
+    const base = { key: target.key, group: target.group, name: target.name, usedBy: target.usedBy, ...(target.custom ? { custom: true } : {}), ...(target.credentials === undefined ? {} : { credentials: target.credentials }) };
     const checked = target.probe === null || row !== undefined;
     const lastSuccessAt = later(row?.okAt ?? null, target.activity.okAt);
     const checkError = row?.error ?? null, checkErrorAt = row?.errorAt ?? null;
@@ -482,20 +489,33 @@ export function integrationsBrokenLine(list) {
     return `Broken integration${broken.length === 1 ? "" : "s"}: ${names}. See \`toolroll integrations\` or Settings → Integrations.`;
 }
 const whenText = (at) => (at === null ? "never" : `${at.slice(0, 16).replace("T", " ")} UTC`);
-/** The CLI's lines: one per integration, then the fix under anything Broken. */
-export function renderIntegrations(list) {
+/** Integrations whose secrets Toolroll holds: project tools, the Linear key, a Google mail connection. */
+const holdsSecrets = (one) => one.group === "tools" || one.key === "linear" || one.key === "email";
+/** The one line about where secrets rest, or null: a folder that can't be used always; files only once something set up holds secrets. */
+export function secretsNote(list, secrets) {
+    if (secrets === null || secrets === undefined)
+        return null;
+    if (secrets.problem !== undefined)
+        return { words: secrets.problem, problem: true };
+    return secrets.filesOnly && list.some(one => holdsSecrets(one) && one.state !== "not-set-up") ? { words: secrets.words, problem: false } : null;
+}
+/** The CLI's lines: one per integration, then the fix under anything Broken; last, where secrets are kept when that is
+ * files only, or why they can't be used (secretsNote). */
+export function renderIntegrations(list, secrets = null) {
     const width = Math.min(24, Math.max(...list.map(one => one.name.length)));
-    return list.flatMap(one => {
-        const facts = [one.account, one.detail].filter(Boolean).join(" · ");
-        const lines = [`${one.name.padEnd(width)}  ${STATE_WORDS[one.state].padEnd(10)}${facts === "" ? "" : `  ${facts}`}`];
-        if (one.state !== "not-set-up")
-            lines.push(`${"".padEnd(width)}  last success ${whenText(one.lastSuccessAt)}${one.lastError === null ? "" : ` · last error ${whenText(one.lastErrorAt)}: ${one.lastError}`}`);
-        if (one.action.kind === "fix")
-            lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}${one.action.command === null || one.action.words.includes(one.action.command) ? "" : ` (run ${one.action.command})`}`);
-        if (one.action.kind === "setup")
-            lines.push(`${"".padEnd(width)}  Set up: ${one.action.command !== null ? `run ${one.action.command}` : `Settings (${one.action.href ?? "/settings"})`}`);
-        return lines;
-    });
+    const said = secretsNote(list, secrets);
+    const note = said === null ? [] : [said.words];
+    return [...list.flatMap(one => {
+            const facts = [one.account, one.detail, one.credentials].filter(Boolean).join(" · ");
+            const lines = [`${one.name.padEnd(width)}  ${STATE_WORDS[one.state].padEnd(10)}${facts === "" ? "" : `  ${facts}`}`];
+            if (one.state !== "not-set-up")
+                lines.push(`${"".padEnd(width)}  last success ${whenText(one.lastSuccessAt)}${one.lastError === null ? "" : ` · last error ${whenText(one.lastErrorAt)}: ${one.lastError}`}`);
+            if (one.action.kind === "fix")
+                lines.push(`${"".padEnd(width)}  Fix: ${one.action.words}${one.action.command === null || one.action.words.includes(one.action.command) ? "" : ` (run ${one.action.command})`}`);
+            if (one.action.kind === "setup")
+                lines.push(`${"".padEnd(width)}  Set up: ${one.action.command !== null ? `run ${one.action.command}` : `Settings (${one.action.href ?? "/settings"})`}`);
+            return lines;
+        }), ...note];
 }
 /** Checks in the background with a short cache, as the first-run suggestions are: a render never waits on a check. */
 export function createIntegrationMonitor(io, options = {}) {

package/dist/invoke.d.ts

@@ -20,6 +20,7 @@ import { type AgentSpec, type Invocation, type ProviderRunner, type AgentEnding
 import { type VersionProbe } from "./attest.js";
 import type { Store } from "./store.js";
 import type { RunOptions } from "./exec.js";
+import { type NetworkProfile } from "./egress.js";
 export type { ProviderRunner } from "./provider.js";
 /** The claude binary name — kept for the legacy quota rows and tests that
  * describe history; new code carries a resolved AgentSpec instead. */
@@ -53,6 +54,8 @@ export type AgentOutcome = {
      * strikes of bad agent work).
      */
     initFailed: boolean;
+    /** An ACP conversation's facts (provider.ts ParsedEnvelope.acp): read by the conformance check only. */
+    acp?: NonNullable<import("./provider.js").ParsedEnvelope["acp"]>;
 };
 /**
  * The value-shaped gateway result (Phase 3 B5): a refusal is a VALUE, so
@@ -78,6 +81,8 @@ export type InvokeResult = {
     /** Bounded agent reply when a spawned turn later failed a protocol
      * gate. Pre-spawn refusals omit it because no reply can exist. */
     finalMessage?: string | null;
+    /** An ACP conversation's facts, when the refusal came after a spawn (the conformance check grades a cancel). */
+    acp?: NonNullable<import("./provider.js").ParsedEnvelope["acp"]>;
 };
 /**
  * Spend money, on the record. Throws — never refuses quietly — when the run
@@ -86,10 +91,22 @@ export type InvokeResult = {
  * bug, not a case. Attestation and protocol refusals are VALUES (above),
  * not throws — those are cases, and they must dispose cleanly.
  */
+/**
+ * What a launch may reach on the network (egress.ts, docs/plans/agent-baseline-hardening.md arc 1). `policy`: the
+ * network a build's approval sealed (or the narrowed legacy one), enforced through the run's own proxy. `via`: the
+ * caller already runs the proxy (a scout's public-web proxy, its browser): only those loopback ports are reachable.
+ * Absent: the provider's own hosts only (a planner, a check — nothing that installs or browses).
+ */
+export type LaunchNetwork = {
+    policy: NetworkProfile;
+} | {
+    via: number[];
+};
 export declare function invokeAgent(store: Store, runId: number, spec: AgentSpec, invocation: Omit<Invocation, "model">, options: RunOptions & {
     runner?: ProviderRunner;
     clock?: () => Date;
     versionProbe?: VersionProbe;
     keyHome?: string;
     accumulateUsage?: boolean;
+    network?: LaunchNetwork;
 }): Promise<InvokeResult>;