toolroll 0.9.67 → 0.9.69

package/dist/cli-http.d.ts

@@ -3,7 +3,6 @@ import type { Store } from './store.js';
 import type { Principal } from './operate.js';
 import { type RemoteCommandLookup } from './remote-command.js';
 import { type Admission, type BudgetLimit } from './request-budget.js';
-import type { SessionRunner } from './session-remote.js';
 /**
  * `POST /api/cli` (remote CLI, Phase 1): a teammate's laptop sends the argv it would have run locally, and the central
  * server runs that same command as that person. There is no per-resource API here and no second policy: the transport
@@ -12,10 +11,6 @@ import type { SessionRunner } from './session-remote.js';
  *
  * Only `Authorization: Bearer so_…` is accepted — never a password, cookie or the owner's saved login — and a request
  * carrying a browser Origin is refused, so a page can never drive it.
- *
- * `session …` (D7) is the one command the server answers through its own owner rather than runOperateAs: native
- * session operations need the server's live coding workspace (session-remote.ts). They are admitted, budgeted and
- * refused here exactly like every other command.
  */
 /** Who a remote command runs as, and the runner: operate.ts's own types, so a change there breaks this build instead of
  * drifting. Type-only: the value is loaded lazily through `run` (operate.ts imports the server that imports this). */
@@ -50,8 +45,6 @@ export type CliHttpOptions = {
     modeOf?: RemoteCommandLookup | undefined;
     /** The token's request budget (request-budget.ts), charged once per request before its body is read. */
     admit?: ((principal: Principal) => Admission) | undefined;
-    /** Native session operations (`session …`), run by the server's session owner; absent where none is ready. */
-    session?: SessionRunner | undefined;
     store: Store;
 };
 /** Decode the request's shape and byte limits. The endpoint checks file references against its command policy. */

package/dist/cli-http.js

@@ -123,8 +123,6 @@ export async function handleCliHttp(request, response, options) {
     const parsed = cliRequest(value);
     if ('problem' in parsed)
         return reject(parsed.tooLarge ? 413 : 400, 'invalid-request', parsed.problem);
-    if (parsed.argv[0] === 'session')
-        return runSession(response, options, principal, parsed);
     const row = (options.modeOf ?? contractRow)(parsed.argv);
     if (row?.mode === 'step-up')
         return reject(403, 'step-up', STEP_UP_MESSAGE);
@@ -161,22 +159,3 @@ export async function handleCliHttp(request, response, options) {
     send(response, 200, { exitCode, stdout: out.join(''), stderr: '' });
     return true;
 }
-/** `session …`: the prompt is the request's one file; the session owner answers one session envelope on stdout. */
-async function runSession(response, options, principal, parsed) {
-    const refuse = (status, code, message) => { send(response, status, { ok: false, code, message }); return true; };
-    if (options.session === undefined)
-        return refuse(501, 'remote-unavailable', 'This server cannot run session commands. Update it, or use the console.');
-    const at = parsed.argv.indexOf('--file'), file = at < 0 ? undefined : parsed.argv[at + 1];
-    if (Object.keys(parsed.files).some(path => path !== file))
-        return refuse(400, 'invalid-request', 'Each file must name a declared input file argument.');
-    const out = [];
-    let exitCode;
-    try {
-        exitCode = await options.session(principal, parsed.argv, parsed.files, line => { out.push(`${line}\n`); });
-    }
-    catch {
-        return refuse(500, 'command-failed', 'The command stopped unexpectedly on the server. Check its state before running it again.');
-    }
-    send(response, 200, { exitCode, stdout: out.join(''), stderr: '' });
-    return true;
-}

package/dist/cli.d.ts

@@ -12,8 +12,7 @@
  */
 import { previewGithubRepo, cloneGithubRepo } from "./onboard.js";
 import { type QuickStartSeams } from "./quick-start.js";
-import { type SessionCliOptions } from "./session-cli.js";
-import { type TeamCliOptions } from "./team-cli.js";
+import { type ConnectOptions } from "./connect-cli.js";
 import { type RemoteExecOptions } from "./remote-exec.js";
 import type { UpdateCliDeps } from "./toolroll-update-cli.js";
 import type { ReleaseCliDeps } from "./release-cli.js";
@@ -47,19 +46,13 @@ type Write = (line: string) => void;
 export { HELP };
 export declare function parseArgs(argv: readonly string[]): ParseResult;
 /** The commands that operate the queue rather than report on the world. */
-/** Every verb the CLI routes OUTSIDE runOperate. Exported (with
- * OPERATE_COMMANDS) so the declared command guide's drift tests compare
- * exact sets instead of regex-reading source. "" is the no-verb report,
- * which answers as `scan`. */
-export declare const TOP_LEVEL_COMMANDS: readonly string[];
 export declare const OPERATE_COMMANDS: Set<string>;
 /** binSource exists so tests can exercise linking without depending on a build. */
 export type MainOptions = {
     binSource?: string;
     operate?: OperateOptions;
-    session?: SessionCliOptions;
-    team?: TeamCliOptions;
-    /** Injected by tests: the remote CLI's profile, fetch and output streams (defaults to `team`'s profile seams). */
+    connect?: ConnectOptions;
+    /** Injected by tests: the remote CLI's profile, fetch and output streams (defaults to `connect`'s profile seams). */
     remote?: RemoteExecOptions;
     /** Injected by tests: the gh-facing halves of `repos add-from-github` —
      * the verb's parsing, gating, and enrollment are what CLI tests prove;

package/dist/cli.js

@@ -26,9 +26,8 @@ import { parseGithubRepo, previewGithubRepo, cloneGithubRepo, isLargeRepo } from
 import { run as execRun } from "./exec.js";
 import { isBareInvocation, runQuickStart } from "./quick-start.js";
 import { COMMAND_GUIDE, SURFACE_NOTES, SURFACE_SCHEMA_VERSION } from "./surface.js";
-import { runSessionCommand, SESSION_CLI_ACTIONS } from "./session-cli.js";
-import { maybeRunTeamCommand, TEAM_CLI_ACTIONS } from "./team-cli.js";
-import { deprecationWarning } from "./deprecations.js";
+import { hasCentralProfile, maybeRunConnectCommand } from "./connect-cli.js";
+import { removedCommand, removedMessage } from "./deprecations.js";
 import { maybeRunRemoteCommand } from "./remote-exec.js";
 import { discover, inspectAll } from "./discover.js";
 import { readPulls } from "./pulls.js";
@@ -107,16 +106,6 @@ export function parseArgs(argv) {
     };
 }
 /** The commands that operate the queue rather than report on the world. */
-/** Every verb the CLI routes OUTSIDE runOperate. Exported (with
- * OPERATE_COMMANDS) so the declared command guide's drift tests compare
- * exact sets instead of regex-reading source. "" is the no-verb report,
- * which answers as `scan`. */
-export const TOP_LEVEL_COMMANDS = [
-    "", "scan", "pulls", "graph", "repos", "repos add", "repos remove", "repos add-from-github",
-    "link", "unlink", "update", "release", "contract", "skills list", "skills get", "skills install", "demo",
-    ...SESSION_CLI_ACTIONS.map(action => `session ${action}`),
-    ...TEAM_CLI_ACTIONS,
-];
 export const OPERATE_COMMANDS = new Set([
     "up",
     // Only `lead token` reaches here; the central service's lead verbs answer first.
@@ -310,21 +299,29 @@ async function dispatch(argv, write, mainOptions) {
     // hidden from help and the contract, before anything remote or local opens, changing nothing.
     if (argv[0] === "routine")
         return routinesMoved(argv, write);
+    // D5: the central team CLI and native sessions are gone; each old invocation says so and changes nothing.
+    const connectOptions = mainOptions.connect ?? mainOptions.remote;
+    const removed = removedCommand(argv, () => hasCentralProfile(connectOptions ?? {}));
+    if (removed !== null) {
+        const message = removedMessage(removed.named, removed.kind);
+        write(argv.includes("--json") ? envelopeJson({ ok: false, command: removed.named, reason: "removed", message }) : message);
+        return 2;
+    }
     // A saved API token sends commands marked remote to the central server, before anything local opens.
     // Command families below load when their command runs, so one command never pays for the others.
     if (argv[0] === 'health')
-        return (await import("./health-cli.js")).runHealthCommand(argv.slice(1), write, mainOptions.team ?? mainOptions.remote);
+        return (await import("./health-cli.js")).runHealthCommand(argv.slice(1), write, mainOptions.connect ?? mainOptions.remote);
     // This computer's own service, read here and never on a central server.
     if (argv[0] === 'doctor')
         return (await import("./doctor.js")).runDoctorCommand(argv.slice(1), write);
-    const central = await maybeRunRemoteCommand(argv, mainOptions.remote ?? mainOptions.team);
+    const central = await maybeRunRemoteCommand(argv, mainOptions.remote ?? mainOptions.connect);
     if (typeof central === "number")
         return central;
     if (central !== null)
         argv = central.local;
-    const team = await maybeRunTeamCommand(argv, write, mainOptions.team);
-    if (team !== null)
-        return team;
+    const connected = await maybeRunConnectCommand(argv, write, mainOptions.connect);
+    if (connected !== null)
+        return connected;
     if ((argv[0] === "chat" || argv[0] === "brief") && argv.includes("--local"))
         argv = argv.filter(arg => arg !== "--local");
     const [first, ...rest] = argv;
@@ -345,12 +342,6 @@ async function dispatch(argv, write, mainOptions) {
     }
     if (first === "contract")
         return runContractCommand(rest, write);
-    if (first === "session") {
-        // D5: native coding sessions are deprecated. They still run this release; each use says so once, on stderr.
-        (mainOptions.session?.stderr ?? (line => process.stderr.write(`${line}\n`)))(deprecationWarning(`session ${rest.find(arg => !arg.startsWith("-")) ?? ""}`.trim(), "session"));
-        // D7: it runs on the saved connection over /api/cli, signed in with that profile's API token.
-        return runSessionCommand(rest, write, { ...(mainOptions.remote ?? mainOptions.team), ...mainOptions.session });
-    }
     if (first === "demo")
         return runDemoCommand(rest, write);
     if (first === "skills")

package/dist/coding-provider.js

@@ -6,6 +6,7 @@ import { createContainer, currentContainment } from "./containment.js";
 import { processMayBeAlive } from "./process-liveness.js";
 import { observeProcessTree, sampleProcessTree, stopProcessTree } from "./process-tree.js";
 import { isOwnEnv } from "./names.js";
+import { sleep } from "./sleep.js";
 /** A response from the server, distinct from an ambiguous transport failure. */
 export class CodingProviderRequestError extends Error {
     code;
@@ -374,7 +375,7 @@ export function createCodexCodingProvider(options = {}) {
             const absent = () => (owned.pid === undefined || !processMayBeAlive(owned.pid, process.platform !== "win32")) && [...descendants.values()].every(({ pid, group }) => !processMayBeAlive(pid, group));
             const until = Date.now() + EXIT_GRACE_MS;
             while (!ancestryUnknown && !absent() && Date.now() < until)
-                await new Promise(resolve => setTimeout(resolve, 25));
+                await sleep(25);
             clean = clean && !ancestryUnknown && absent();
         }
         if (!clean)

package/dist/coding-workspace.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { mkdirSync, chmodSync, realpathSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { dirname, join } from 'node:path';
 import { hostname } from 'node:os';
 import { provenDeadByBootChange } from './boot-identity.js';
 import { containerEmptiness } from './container-state.js';

package/dist/{team-cli.d.ts → connect-cli.d.ts}

@@ -1,17 +1,12 @@
-export type TeamCliOptions = {
+export type ConnectOptions = {
     fetch?: typeof fetch;
     env?: NodeJS.ProcessEnv;
     home?: string;
     profileFile?: string;
     readStdin?: () => Promise<string>;
-    readLine?: (prompt: string) => Promise<string | null>;
-    isTTY?: boolean;
     stderr?: (line: string) => void;
     signal?: AbortSignal;
-    sleep?: (milliseconds: number, signal: AbortSignal) => Promise<void>;
 };
-/** D5: deprecated (deprecations.ts). Each still runs this release, hidden from help and the contract, with one warning on stderr. */
-export declare const TEAM_CLI_ACTIONS: readonly ['connect', 'lead list', 'lead create', 'lead update', 'lead member', 'lead transfer', 'conversation list', 'conversation create', 'conversation show', 'conversation member', 'conversation edit', 'conversation withdraw', 'conversation read', 'conversation follow', 'conversation stop'];
 export declare class UsageError extends Error {
 }
 /** Credentials are never sent to a URL with embedded authority, an API path, query, fragment or an insecure remote
@@ -26,13 +21,14 @@ type Profile = {
 export declare const bearerOf: (profile: Profile) => string;
 /** The saved central profile remote commands use: the named one (or the active one), and whether it holds an API token.
  * null when nothing is saved. Reads only the private profile file — never a local login or the database. */
-export declare function centralProfile(options: TeamCliOptions, name?: string): {
+export declare function hasCentralProfile(options: ConnectOptions): boolean;
+export declare function centralProfile(options: ConnectOptions, name?: string): {
     name: string;
     origin: string;
     account: string;
     token: string;
     apiToken: boolean;
 } | null;
-/** null means preserve the existing local command path. Nothing here opens a database. */
-export declare function maybeRunTeamCommand(argv: readonly string[], write: (line: string) => void, options?: TeamCliOptions): Promise<number | null>;
+/** `toolroll connect …`; null for every other command. Nothing here opens a database. */
+export declare function maybeRunConnectCommand(argv: readonly string[], write: (line: string) => void, options?: ConnectOptions): Promise<number | null>;
 export {};

package/dist/connect-cli.js

@@ -0,0 +1,331 @@
+/**
+ * `toolroll connect`: saves a central server's origin and your API token in a private profile file. Remote commands
+ * (remote-exec.ts) and `toolroll health` sign in with it; nothing here opens the local database except to find the
+ * existing local sign-in for --local-login.
+ */
+import { constants, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { envelopeJson } from './envelope.js';
+import { databasePath } from './store.js';
+import { configBase, namedPath } from './names.js';
+import { parseApiToken } from './api-tokens.js';
+import { deprecationWarning } from './deprecations.js';
+import { PASSWORD_PROFILE_WARNING } from './password-bearer.js';
+const HELP = `toolroll connect <HTTPS-origin> --as <account> --token-stdin
+  Pipe your API token (so_…, from Settings → API tokens) or use --token-file <private-file>;
+  --local-login uses your existing local sign-in.
+  With an API token saved, other commands run on that server as you (--local runs here).
+  Optional: --profile <name> (saved as the active profile).`;
+export class UsageError extends Error {
+}
+/** Credentials are never sent to a URL with embedded authority, an API path, query, fragment or an insecure remote
+ * host. Fetch cannot follow redirects. */
+export function serviceOrigin(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new UsageError('The service origin must be HTTPS or loopback HTTP.');
+    }
+    if (url.username || url.password || url.search || url.hash || url.pathname !== '/')
+        throw new UsageError('The service origin must contain only the origin, with no credentials, path, query or fragment.');
+    if (url.protocol !== 'https:' && !(url.protocol === 'http:' && ['127.0.0.1', '[::1]', 'localhost'].includes(url.hostname)))
+        throw new UsageError('The service origin requires HTTPS except for loopback HTTP.');
+    return url.origin;
+}
+const value = (flags, name) => typeof flags[name] === 'string' ? flags[name] : '';
+const text = (raw) => raw.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '');
+const record = (input) => !!input && typeof input === 'object' && !Array.isArray(input);
+const strings = (input) => Array.isArray(input) && input.every(one => typeof one === 'string');
+const accountValid = (input) => !!input && input.length <= 200 && !/[\s:\x00-\x1f\x7f]/.test(input);
+const tokenValid = (input) => !!input && input.length <= 8192 && !/[\s\x00-\x1f\x7f]/.test(input);
+const profilePath = (options) => options.profileFile ?? namedPath(configBase(options.env ?? process.env, options.home ?? homedir()), ['remote', 'profiles.json']);
+/** Open the file itself without following a symlink; nonblocking also rejects FIFOs safely. */
+function privateFile(path, limit) {
+    let fd;
+    try {
+        fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        const stat = fstatSync(fd);
+        if (!stat.isFile() || (stat.mode & 0o777) !== 0o600 || (process.getuid && stat.uid !== process.getuid()) || stat.size > limit)
+            throw new Error();
+        const bytes = readFileSync(fd);
+        if (bytes.length > limit)
+            throw new Error();
+        return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+    }
+    catch {
+        throw new UsageError('The credential file must be an owned, private (chmod 600), regular UTF-8 file.');
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+    }
+}
+function profiles(options) {
+    const path = profilePath(options);
+    // lstat distinguishes a dangling symlink from a missing profile.
+    try {
+        lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw new UsageError('The remote profile cannot be read.');
+    }
+    const raw = privateFile(path, 128 * 1024);
+    try {
+        const parsed = JSON.parse(raw);
+        if (!record(parsed) || parsed.version !== 1 || typeof parsed.active !== 'string' || !record(parsed.profiles))
+            throw new Error();
+        for (const [name, one] of Object.entries(parsed.profiles)) {
+            if (!/^[A-Za-z0-9_-]{1,64}$/.test(name) || !record(one) || typeof one.origin !== 'string' || serviceOrigin(one.origin) !== one.origin || typeof one.account !== 'string' || !accountValid(one.account) || typeof one.token !== 'string' || !tokenValid(one.token))
+                throw new Error();
+        }
+        if (!Object.hasOwn(parsed.profiles, parsed.active))
+            throw new Error();
+        return parsed;
+    }
+    catch {
+        throw new UsageError('The remote profile is invalid. Connect again using a private credential source.');
+    }
+}
+function saveProfile(options, name, profile) {
+    const path = profilePath(options), directory = dirname(path);
+    const saved = profiles(options) ?? { version: 1, active: name, profiles: {} };
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const parent = lstatSync(directory);
+    if (!parent.isDirectory() || (parent.mode & 0o777) !== 0o700 || (process.getuid && parent.uid !== process.getuid()))
+        throw new UsageError('The remote profile directory must be owned and private (chmod 700).');
+    saved.active = name;
+    Object.defineProperty(saved.profiles, name, { value: profile, enumerable: true, configurable: true, writable: true });
+    const temporary = join(directory, `.profile-${randomBytes(16).toString('hex')}`);
+    let fd;
+    try {
+        fd = openSync(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+        writeFileSync(fd, `${JSON.stringify(saved)}\n`);
+        fsyncSync(fd);
+        closeSync(fd);
+        fd = undefined;
+        renameSync(temporary, path);
+        fd = openSync(directory, constants.O_RDONLY);
+        fsyncSync(fd);
+    }
+    finally {
+        if (fd !== undefined)
+            closeSync(fd);
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+/** An API token (so_…) is sent bare; an older saved sign-in keeps its account:secret form. */
+export const bearerOf = (profile) => parseApiToken(profile.token) !== null ? `Bearer ${profile.token}` : `Bearer ${profile.account}:${profile.token}`;
+/** The saved central profile remote commands use: the named one (or the active one), and whether it holds an API token.
+ * null when nothing is saved. Reads only the private profile file — never a local login or the database. */
+export function hasCentralProfile(options) {
+    // An unreadable or invalid profile file still names a central service: the caller refuses rather than run locally.
+    try {
+        return profiles(options) !== null;
+    }
+    catch {
+        return true;
+    }
+}
+export function centralProfile(options, name) {
+    const saved = profiles(options);
+    if (saved === null)
+        return null;
+    const chosen = name ?? saved.active;
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(chosen) || !Object.hasOwn(saved.profiles, chosen))
+        throw new UsageError(`No saved connection named ${chosen}. Use connect with your API token first.`);
+    const profile = saved.profiles[chosen];
+    return { name: chosen, ...profile, apiToken: parseApiToken(profile.token) !== null };
+}
+async function stdinSecret() {
+    if (process.stdin.isTTY)
+        throw new UsageError('Pipe your sign-in secret into --token-stdin, or use --token-file.');
+    const chunks = [];
+    let size = 0;
+    for await (const part of process.stdin) {
+        const chunk = Buffer.from(part);
+        size += chunk.length;
+        if (size > 8192)
+            throw new UsageError('The sign-in secret is too large.');
+        chunks.push(chunk);
+    }
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks));
+    }
+    catch {
+        throw new UsageError('The sign-in secret must be UTF-8.');
+    }
+}
+async function responseBody(response) {
+    if (!response.body)
+        throw new Error();
+    const reader = response.body.getReader(), chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            size += chunk.value.byteLength;
+            if (size > 2 * 1024 * 1024) {
+                await reader.cancel();
+                throw new Error();
+            }
+            chunks.push(chunk.value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(Buffer.concat(chunks)));
+}
+function parse(argv) {
+    const allowed = new Set(['profile', 'json', 'help', 'as', 'token-stdin', 'token-file', 'local-login', 'login-file']);
+    const switches = new Set(['json', 'help', 'token-stdin', 'local-login']);
+    const flags = {}, positions = [];
+    for (let index = 1; index < argv.length; index++) {
+        const arg = argv[index];
+        if (!arg.startsWith('--')) {
+            positions.push(arg);
+            continue;
+        }
+        const name = arg.slice(2);
+        if (!allowed.has(name))
+            throw new UsageError('Unsupported option. Use --help for this command; secrets must come from stdin or a private file.');
+        if (Object.hasOwn(flags, name))
+            throw new UsageError(`Use --${name} only once.`);
+        if (switches.has(name))
+            flags[name] = true;
+        else {
+            const next = argv[++index];
+            if (!next || next.startsWith('--'))
+                throw new UsageError(`--${name} needs a value.`);
+            flags[name] = next;
+        }
+    }
+    if (positions.length !== 1 && !flags.help)
+        throw new UsageError('Name one service origin.');
+    return { flags, positions };
+}
+function isMessage(one) {
+    return record(one) && Number.isSafeInteger(one.id) && typeof one.author === 'string' && ['operator', 'assistant'].includes(String(one.role)) && typeof one.text === 'string' && ['queued', 'running', 'answered', 'failed', 'cancelled', 'uncertain'].includes(String(one.status)) && Number.isSafeInteger(one.revision) && typeof one.createdAt === 'string' && (one.requestId === null || typeof one.requestId === 'string') && (one.turnId === null || Number.isSafeInteger(one.turnId)) && (one.error === null || typeof one.error === 'string');
+}
+/** The listing a central service answers `list` with; a reply without a well-formed one is no proof of a service. */
+function isSnapshot(one) {
+    if (!record(one) || !Array.isArray(one.leads) || !one.leads.every(lead => record(lead) && typeof lead.id === 'string' && typeof lead.name === 'string') || !Array.isArray(one.conversations) || !one.conversations.every(conversation => record(conversation) && typeof conversation.id === 'string' && typeof conversation.leadId === 'string' && typeof conversation.title === 'string') || !(one.selected === null || record(one.selected) && typeof one.selected.id === 'string' && typeof one.selected.leadId === 'string' && typeof one.selected.title === 'string') || !Array.isArray(one.participants) || !one.participants.every(participant => record(participant) && typeof participant.account === 'string' && ['viewer', 'contributor', 'manager'].includes(String(participant.role)) && typeof participant.active === 'boolean') || !Array.isArray(one.messages) || !one.messages.every(isMessage) || typeof one.canManage !== 'boolean' || typeof one.canSend !== 'boolean' || !Number.isSafeInteger(one.cursor) || typeof one.truncated !== 'boolean' || !strings(one.projects) || !strings(one.accounts))
+        return false;
+    if (one.chatAuthorization !== undefined) {
+        const grant = one.chatAuthorization;
+        if (!record(grant) || typeof grant.enabled !== 'boolean' || !(grant.provider === null || typeof grant.provider === 'string') || !(grant.model === null || typeof grant.model === 'string') || !Number.isSafeInteger(grant.dailyTurns) || ![grant.weeklyCeilingUsd, grant.conversationCeilingUsd].every(amount => amount === null || typeof amount === 'number' && Number.isFinite(amount) && amount >= 0) || typeof grant.termsDigest !== 'string')
+            return false;
+    }
+    if (one.tasks !== undefined) {
+        const tasks = one.tasks;
+        if (!record(tasks) || !record(tasks.totals) || !['all', 'needs-you', 'running', 'completed'].every(key => Number.isSafeInteger(tasks.totals[key])) || !Array.isArray(tasks.items) || !tasks.items.every(task => record(task) && typeof task.rootId === 'string' && typeof task.activeTaskId === 'string' && typeof task.title === 'string' && record(task.status) && typeof task.status.label === 'string') || !(tasks.nextCursor === null || typeof tasks.nextCursor === 'string'))
+            return false;
+    }
+    if (one.proposals !== undefined && (!Array.isArray(one.proposals) || !one.proposals.every(proposal => record(proposal) && Number.isSafeInteger(proposal.id) && typeof proposal.title === 'string' && typeof proposal.state === 'string' && typeof proposal.href === 'string')))
+        return false;
+    return true;
+}
+/** The server must accept the credential before it is saved: one read of POST /api/team, never retried. A success
+ * proves itself with a well-formed listing, as the central `list` it is. */
+async function verify(profile, options) {
+    const unconfirmed = { version: 1, ok: false, code: 'service-unavailable', message: 'The service response could not be read.' };
+    try {
+        const response = await (options.fetch ?? fetch)(`${profile.origin}/api/team`, { method: 'POST', redirect: 'manual', credentials: 'omit', signal: options.signal ? AbortSignal.any([options.signal, AbortSignal.timeout(30_000)]) : AbortSignal.timeout(30_000), headers: { authorization: bearerOf(profile), 'content-type': 'application/json', accept: 'application/json' }, body: JSON.stringify({ operation: 'list', args: {} }) });
+        if (response.status >= 300 && response.status < 400) {
+            await response.body?.cancel();
+            return unconfirmed;
+        }
+        if (response.status === 429) {
+            await response.body?.cancel();
+            return { ...unconfirmed, code: 'rate-limited', message: 'Request limit reached. Try again shortly.' };
+        }
+        const payload = await responseBody(response);
+        if (!record(payload) || payload.version !== 1 || typeof payload.ok !== 'boolean' || typeof payload.code !== 'string' || typeof payload.message !== 'string' || payload.snapshot !== undefined && !isSnapshot(payload.snapshot) || payload.ok && !response.ok)
+            return unconfirmed;
+        if (payload.ok && payload.snapshot === undefined)
+            return unconfirmed;
+        return { version: 1, ok: payload.ok, code: payload.code, message: payload.message };
+    }
+    catch {
+        return unconfirmed;
+    }
+}
+/** `toolroll connect …`; null for every other command. Nothing here opens a database. */
+export async function maybeRunConnectCommand(argv, write, options = {}) {
+    if (argv[0] !== 'connect')
+        return null;
+    const json = argv.includes('--json');
+    let secret = '';
+    const stderr = (line) => (options.stderr ?? (line => process.stderr.write(`${line}\n`)))(text(secret ? line.replaceAll(secret, '[redacted]') : line));
+    const emit = (reply) => {
+        // A server's words can echo the credential it was sent: every string it says is redacted before it is shown.
+        const safe = JSON.parse(JSON.stringify(reply, (_key, one) => typeof one === 'string' && secret ? one.replaceAll(secret, '[redacted]') : one));
+        write(json ? envelopeJson({ ...safe, command: 'team connect' }) : text(safe.message));
+    };
+    try {
+        // D5: `connect` belongs to the deprecated central team service; it still saves the profile remote commands use.
+        stderr(deprecationWarning('connect', 'team'));
+        if (argv.includes('--help')) {
+            write(HELP);
+            return 0;
+        }
+        const { flags, positions } = parse(argv);
+        if (flags.help) {
+            write(HELP);
+            return 0;
+        }
+        const profileName = value(flags, 'profile') || 'default';
+        if (!/^[A-Za-z0-9_-]{1,64}$/.test(profileName))
+            throw new UsageError('Profile names use 1–64 letters, digits, underscores or hyphens.');
+        let origin;
+        try {
+            origin = serviceOrigin(positions[0]);
+        }
+        catch {
+            throw new UsageError('Use an HTTPS service origin (loopback HTTP is allowed), without credentials, paths, query or fragment.');
+        }
+        if (['token-stdin', 'token-file', 'local-login'].filter(name => flags[name]).length !== 1)
+            throw new UsageError('Choose one credential source: --token-stdin, --token-file or --local-login.');
+        if (flags['login-file'] && !flags['local-login'])
+            throw new UsageError('--login-file requires --local-login.');
+        let account = value(flags, 'as');
+        if (flags['local-login']) {
+            const login = privateFile(value(flags, 'login-file') || join(dirname(databasePath(options.env ?? process.env, options.home ?? homedir())), 'up-login.txt'), 8192).trim().split(/\s+/);
+            if (login.length !== 2 || account && account !== login[0])
+                throw new UsageError('The local sign-in does not match the requested account.');
+            account = login[0];
+            secret = login[1];
+        }
+        else
+            secret = (flags['token-file'] ? privateFile(value(flags, 'token-file'), 8192) : await (options.readStdin ?? stdinSecret)()).trim();
+        if (!accountValid(account) || !tokenValid(secret))
+            throw new UsageError('Provide an account name and a valid sign-in secret from your selected source.');
+        if (parseApiToken(secret) === null)
+            stderr(PASSWORD_PROFILE_WARNING);
+        const profile = { origin, account, token: secret }, checked = await verify(profile, options);
+        if (!checked.ok) {
+            emit(checked);
+            return 1;
+        }
+        saveProfile(options, profileName, profile);
+        emit({ version: 1, ok: true, code: 'connected', message: `Connected to ${origin} as ${account}.`, result: { profile: profileName, origin, account } });
+        return 0;
+    }
+    catch (error) {
+        const reply = { version: 1, ok: false, code: 'usage', message: error instanceof UsageError ? error.message : 'The connection could not be prepared. Check the private profile and credential files.' };
+        if (json)
+            emit(reply);
+        else
+            stderr(text(reply.message));
+        return 2;
+    }
+}

package/dist/containment.d.ts

@@ -198,5 +198,3 @@ export declare function cgroup2Container(capability: ContainmentCapability, labe
  * the CI windows job exercises it.
  */
 export declare function jobObjectContainer(capability: ContainmentCapability, label: string): Container;
-/** Where the Windows helper lives beside this module (dist or src). */
-export declare function containmentModuleDir(): string;

package/dist/containment.js

@@ -36,9 +36,10 @@ import { randomBytes } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmdirSync, writeFileSync } from "node:fs";
 import { captureCgroupIdentity, cgroupEmptiness, containerEmptiness } from "./container-state.js";
 import { createServer } from "node:net";
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { envValue } from "./names.js";
+import { sleep } from "./sleep.js";
 export const CONTAINMENT_POLICIES = ["observed", "preferred", "required"];
 /** The environment name the controller reads when no flag names a policy. */
 export const CONTAINMENT_ENV = "TOOLROLL_CONTAINMENT";
@@ -278,7 +279,6 @@ export function createContainer(effective, label) {
         return { refused: `native containment could not be established for this spawn (${error instanceof Error ? error.message : String(error)}) — nothing ran` };
     }
 }
-const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 /**
  * The cgroup2 prelude: join, confirm on fd 3, close it, exec the target
  * with argv exactly as given (positional parameters, never re-parsed).
@@ -562,7 +562,3 @@ export function jobObjectContainer(capability, label) {
         },
     };
 }
-/** Where the Windows helper lives beside this module (dist or src). */
-export function containmentModuleDir() {
-    return dirname(fileURLToPath(import.meta.url));
-}

package/dist/contracts/chat-actions.d.ts

@@ -267,7 +267,6 @@ export declare const chatActionRequestSchemas: {
 };
 export type ChatActionOperation = keyof typeof chatActionRequestSchemas;
 export declare const CHAT_ACTION_OPERATIONS: [ChatActionOperation, ...ChatActionOperation[]];
-export type ChatActionRequest<O extends ChatActionOperation = ChatActionOperation> = z.infer<(typeof chatActionRequestSchemas)[O]>;
 /** The fields each action takes, from its schema. */
 export declare const CHAT_ACTION_FIELDS: Record<ChatActionOperation, readonly string[]>;
 /** One action's data, refused by path (`card: required`, `payload: unknown key 'cards' (did you mean card?)`). */

package/dist/contracts/chat-content.d.ts

@@ -335,10 +335,6 @@ export declare const chatActionBodySchema: z.ZodUnion<readonly [z.ZodObject<{
     version: z.ZodLiteral<1>;
     problem: z.ZodString;
 }, z.core.$strict>]>;
-/** A notice carries its parts, not a body. */
-export declare const chatNoticeBodySchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-}, z.core.$strict>;
 export type ChatPairBody = z.infer<typeof chatPairBodySchema>;
 export type ChatMessageBody = z.infer<typeof chatMessageBodySchema>;
 export type ChatActionBody = z.infer<typeof chatActionBodySchema>;

package/dist/contracts/chat-content.js

@@ -125,8 +125,6 @@ export const chatMessageBodySchema = versioned(CHAT_EVENT_VERSION, {
 export const chatTokenBodySchema = versioned(CHAT_EVENT_VERSION, { token: z.string().regex(CHAT_BUTTON_TOKEN, { error: "must be a Toolroll button token" }) });
 export const chatProblemBodySchema = versioned(CHAT_EVENT_VERSION, { problem: z.string().min(1) });
 export const chatActionBodySchema = z.union([chatTokenBodySchema, chatProblemBodySchema]);
-/** A notice carries its parts, not a body. */
-export const chatNoticeBodySchema = versioned(CHAT_EVENT_VERSION, {});
 export function savedChatEventBody(body) {
     return JSON.stringify({ version: CHAT_EVENT_VERSION, ...body });
 }

package/dist/contracts/chat-tables.d.ts

@@ -10,4 +10,3 @@ export declare const isChatProvider: (value: unknown) => value is ChatProvider;
 export declare const CHAT_SCHEMA: string;
 /** Every shared chat table, parents before children. */
 export declare const CHAT_TABLES: readonly ["chat_binding", "chat_pair", "chat_event", "chat_part", "chat_action", "chat_progress", "chat_runtime", "chat_room", "chat_meta", "chat_flow_action", "chat_flow_prompt", "chat_flow_choice", "chat_flow_note", "chat_question_action", "chat_question_prompt", "chat_ask_action", "chat_message_ref", "chat_note_draft", "chat_digest"];
-export type ChatTable = (typeof CHAT_TABLES)[number];