team 0.0.1 → 0.1.0

package/dist/watch/screen-file.js

@@ -0,0 +1,269 @@
+// A profile file, in team's YAML subset, checked as it is loaded. The JSON Schema
+// next to the profiles describes the same shape; this is what actually refuses a file,
+// because the package does not carry a schema validator.
+import { DialectError, compilePattern } from "./dialect.js";
+import { YamlError, parseYaml } from "../yaml.js";
+const STAGES = ['unknown', 'trust', 'permission', 'question', 'working'];
+const KINDS = ['idle', 'working', 'unsent', 'permission', 'trust', 'question', 'unknown'];
+const CHOICE_SAMPLES = ['❯ 1. Yes', '› 1. Yes', '> 1. Yes', '❯ 1.', '› 1.', '> 1.'];
+export function loadScreen(text) {
+    const root = parseYaml(text);
+    const entries = mapping(root, 'a profile');
+    // Launch keys are read by profile.ts. A screen-only snippet, as in the tests, omits them.
+    only(entries, ['format', 'cli', 'screen', 'quota', 'binary', 'process_names', 'tested', 'unattended', 'rules', 'login', 'exit', 'timeouts', 'models', 'status_model']);
+    const format = required(entries, 'format', root.line);
+    if (format.value.kind !== 'scalar' || format.value.value !== 1)
+        fail(format.line, '"format" must be 1');
+    const cli = required(entries, 'cli', root.line);
+    if (!stringOf(cli.value))
+        fail(cli.line, '"cli" must be a string');
+    const screen = required(entries, 'screen', root.line);
+    return screenOf(screen.value);
+}
+function screenOf(node) {
+    const entries = mapping(node, 'screen');
+    only(entries, ['chrome', 'composer', ...STAGES]);
+    const chrome = optional(entries, 'chrome');
+    const composer = required(entries, 'composer', node.line);
+    const data = {
+        chrome: chrome ? chromeOf(chrome.value) : [],
+        composer: composerOf(composer.value),
+    };
+    for (const name of STAGES) {
+        const entry = optional(entries, name);
+        if (entry)
+            data[name] = stageOf(entry.value);
+    }
+    return data;
+}
+function stageOf(node) {
+    if (node.kind === 'seq')
+        return { rules: node.items.map((item) => ruleOf(item, false)) };
+    const entries = mapping(node, 'a stage');
+    only(entries, ['ignore_case', 'rules']);
+    const flag = optional(entries, 'ignore_case');
+    const ignoreCase = flag ? boolOf(flag.value, 'ignore_case') : false;
+    const rules = required(entries, 'rules', node.line);
+    if (rules.value.kind !== 'seq')
+        fail(rules.line, '"rules" must be a list');
+    return { rules: rules.value.items.map((item) => ruleOf(item, ignoreCase)) };
+}
+function ruleOf(node, ignoreCase) {
+    const entries = mapping(node, 'a rule');
+    only(entries, ['any', 'all', 'footer', 'below_last_rule', 'none_after']);
+    if (entries.length === 0)
+        fail(node.line, 'a rule has no primitive');
+    const rule = {};
+    const any = optional(entries, 'any');
+    const all = optional(entries, 'all');
+    const footer = optional(entries, 'footer');
+    const below = optional(entries, 'below_last_rule');
+    const noneAfter = optional(entries, 'none_after');
+    if (any)
+        rule.any = patternsOf(any.value, 'any', ignoreCase);
+    if (all)
+        rule.all = patternsOf(all.value, 'all', ignoreCase);
+    if (footer)
+        rule.footer = stringOf(footer.value) ?? fail(footer.line, '"footer" must be a string');
+    if (below)
+        rule.belowLastRule = patternOf(stringOf(below.value) ?? fail(below.line, '"below_last_rule" must be a string'), ignoreCase, below.line);
+    if (noneAfter)
+        rule.noneAfter = noneAfterOf(noneAfter.value, ignoreCase);
+    return rule;
+}
+function noneAfterOf(node, ignoreCase) {
+    const entries = mapping(node, 'none_after');
+    only(entries, ['anchor', 'patterns']);
+    const anchor = required(entries, 'anchor', node.line);
+    const patterns = required(entries, 'patterns', node.line);
+    return {
+        anchor: linePattern(anchor.value, ignoreCase),
+        patterns: patternsOf(patterns.value, 'patterns', ignoreCase),
+    };
+}
+function patternsOf(node, key, ignoreCase) {
+    if (node.kind !== 'seq' || node.items.length === 0)
+        fail(node.line, `"${key}" must be a non-empty list`);
+    return node.items.map((item) => linePattern(item, ignoreCase));
+}
+function linePattern(node, ignoreCase) {
+    if (node.kind === 'scalar') {
+        const text = stringOf(node);
+        if (text === null)
+            fail(node.line, 'a pattern must be a string');
+        return { match: patternOf(text, ignoreCase, node.line), except: [] };
+    }
+    const entries = mapping(node, 'a pattern');
+    only(entries, ['match', 'except']);
+    const match = required(entries, 'match', node.line);
+    const text = stringOf(match.value);
+    if (text === null)
+        fail(match.line, '"match" must be a string');
+    const except = optional(entries, 'except');
+    return { match: patternOf(text, ignoreCase, match.line), except: except ? exceptOf(except.value, ignoreCase) : [] };
+}
+function exceptOf(node, ignoreCase) {
+    if (node.kind !== 'seq' || node.items.length === 0)
+        fail(node.line, '"except" must be a non-empty list');
+    return node.items.map((item) => {
+        const text = stringOf(item);
+        if (text === null)
+            fail(item.line, '"except" entries must be strings');
+        return patternOf(text, ignoreCase, item.line);
+    });
+}
+function composerOf(node) {
+    const entries = mapping(node, 'composer');
+    const mode = required(entries, 'mode', node.line);
+    const name = stringOf(mode.value);
+    if (name === 'box-to-rule') {
+        only(entries, ['mode', 'prompt', 'rule', 'placeholders']);
+        return { mode: name, prompt: regexField(entries, 'prompt', node.line), rule: regexField(entries, 'rule', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value) };
+    }
+    if (name === 'status-last') {
+        only(entries, ['mode', 'status_line', 'prompt', 'placeholders']);
+        return { mode: name, statusLine: regexField(entries, 'status_line', node.line), prompt: regexField(entries, 'prompt', node.line), placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value) };
+    }
+    if (name === 'status-then-one') {
+        only(entries, ['mode', 'status_line', 'prompt', 'placeholders', 'strip_suffix', 'fallback']);
+        const suffix = optional(entries, 'strip_suffix');
+        const fallback = required(entries, 'fallback', node.line);
+        return {
+            mode: name,
+            statusLine: regexField(entries, 'status_line', node.line),
+            prompt: regexField(entries, 'prompt', node.line),
+            placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
+            stripSuffix: suffix ? patternOf(stringOf(suffix.value) ?? fail(suffix.line, '"strip_suffix" must be a string'), false, suffix.line) : null,
+            fallback: fallbackOf(fallback.value),
+        };
+    }
+    if (name === 'two-rules-footer-below') {
+        only(entries, ['mode', 'ignore_case', 'prompt', 'rule', 'footers', 'placeholders']);
+        const flag = optional(entries, 'ignore_case');
+        const ignoreCase = flag ? boolOf(flag.value, 'ignore_case') : false;
+        const footers = required(entries, 'footers', node.line);
+        if (footers.value.kind !== 'seq' || footers.value.items.length === 0)
+            fail(footers.line, '"footers" must be a non-empty list');
+        return {
+            mode: name,
+            prompt: regexField(entries, 'prompt', node.line, ignoreCase),
+            rule: regexField(entries, 'rule', node.line, ignoreCase),
+            footers: footers.value.items.map((item) => {
+                const text = stringOf(item);
+                if (text === null)
+                    fail(item.line, '"footers" entries must be strings');
+                return patternOf(text, ignoreCase, item.line);
+            }),
+            placeholders: placeholdersOf(required(entries, 'placeholders', node.line).value),
+        };
+    }
+    fail(mode.line, `"mode" must be box-to-rule, status-last, status-then-one or two-rules-footer-below`);
+}
+function fallbackOf(node) {
+    if (node.kind !== 'seq')
+        fail(node.line, '"fallback" must be a list');
+    return node.items.map((item) => {
+        const entries = mapping(item, 'a fallback rule');
+        only(entries, ['all', 'kind']);
+        const kind = required(entries, 'kind', item.line);
+        const name = stringOf(kind.value);
+        if (!name || !KINDS.includes(name))
+            fail(kind.line, '"kind" is not a screen kind');
+        return { all: patternsOf(required(entries, 'all', item.line).value, 'all', false), kind: name };
+    });
+}
+function placeholdersOf(node) {
+    if (node.kind !== 'seq')
+        fail(node.line, '"placeholders" must be a list');
+    return node.items.map((item) => {
+        const entries = mapping(item, 'a placeholder');
+        only(entries, ['equals', 'prefix']);
+        const equals = optional(entries, 'equals');
+        const prefix = optional(entries, 'prefix');
+        if (equals && prefix)
+            fail(item.line, 'a placeholder is "equals" or "prefix", not both');
+        if (equals) {
+            const text = stringOf(equals.value);
+            if (text === null)
+                fail(equals.line, '"equals" must be a string');
+            return { equals: text };
+        }
+        if (prefix) {
+            const text = stringOf(prefix.value);
+            if (!text)
+                fail(prefix.line, '"prefix" must be a non-empty string');
+            return { prefix: text };
+        }
+        fail(item.line, 'a placeholder needs "equals" or "prefix"');
+    });
+}
+function chromeOf(node) {
+    if (node.kind !== 'seq')
+        fail(node.line, '"chrome" must be a list');
+    return node.items.map((item) => {
+        const text = stringOf(item);
+        if (text === null)
+            fail(item.line, '"chrome" entries must be strings');
+        if (!anchored(text))
+            fail(item.line, 'a chrome pattern must match the whole line: "^…$"');
+        const compiled = patternOf(text, false, item.line);
+        if (CHOICE_SAMPLES.some((sample) => compiled.test(sample))) {
+            fail(item.line, 'a chrome pattern would match a numbered choice line');
+        }
+        return compiled;
+    });
+}
+function regexField(entries, key, line, ignoreCase = false) {
+    const entry = required(entries, key, line);
+    const text = stringOf(entry.value);
+    if (text === null)
+        fail(entry.line, `"${key}" must be a string`);
+    return patternOf(text, ignoreCase, entry.line);
+}
+function patternOf(text, ignoreCase, line) {
+    try {
+        return compilePattern(text, ignoreCase);
+    }
+    catch (error) {
+        if (error instanceof DialectError)
+            fail(line, error.message);
+        throw error;
+    }
+}
+function anchored(text) {
+    if (!text.startsWith('^') || !text.endsWith('$'))
+        return false;
+    let slashes = 0;
+    for (let i = text.length - 2; i >= 0 && text[i] === '\\'; i--)
+        slashes++;
+    return slashes % 2 === 0;
+}
+function mapping(node, what) {
+    if (node.kind !== 'map')
+        fail(node.line, `${what} must be a map`);
+    return node.entries;
+}
+function only(entries, allowed) {
+    for (const entry of entries)
+        if (!allowed.includes(entry.key))
+            fail(entry.line, `unknown key "${entry.key}"`);
+}
+function required(entries, key, line) {
+    return optional(entries, key) ?? fail(line, `missing "${key}"`);
+}
+function optional(entries, key) {
+    return entries.find((entry) => entry.key === key);
+}
+function stringOf(node) {
+    if (node.kind !== 'scalar' || typeof node.value !== 'string')
+        return null;
+    return node.value;
+}
+function boolOf(node, key) {
+    if (node.kind !== 'scalar' || typeof node.value !== 'boolean')
+        fail(node.line, `"${key}" must be true or false`);
+    return node.value;
+}
+function fail(line, message) {
+    throw new YamlError(line, message);
+}

package/dist/watch/screen.d.ts

@@ -0,0 +1,20 @@
+export type Screen = {
+    kind: 'idle';
+} | {
+    kind: 'working';
+} | {
+    kind: 'unsent';
+} | {
+    kind: 'permission';
+} | {
+    kind: 'trust';
+} | {
+    kind: 'question';
+} | {
+    kind: 'unknown';
+};
+/** Every stage, in the core's order. The first one that matches wins. */
+export declare function classify(cli: string, lines: string[]): Screen;
+/** The composer alone. A running turn would otherwise hide an empty input box. */
+export declare function classifyComposer(cli: string, lines: string[]): Screen;
+export declare function readScreen(cli: string, screen: string | undefined): Screen;

package/dist/watch/screen.js

@@ -0,0 +1,38 @@
+// What a pane's visible text shows, read against the shapes of its CLI. A screen that matches no
+// shape is "unknown": never ready, never idle, and never grounds for typing anything.
+import { readFileSync } from 'node:fs';
+import { classifyLines, composeLines } from "./screen-core.js";
+import { loadScreen } from "./screen-file.js";
+function load(name) {
+    return loadScreen(readFileSync(new URL(`../profiles/${name}.yaml`, import.meta.url), 'utf8'));
+}
+// Every shipped CLI is data. The core owns the order.
+const DATA = {
+    'claude-code': load('claude-code'),
+    codex: load('codex'),
+    cursor: load('cursor'),
+    antigravity: load('antigravity'),
+};
+// The window every pattern sees: the pane's last 20 lines, each trimmed at the end.
+function windowOf(lines) {
+    return lines.map((line) => line.trimEnd()).slice(-20);
+}
+/** Every stage, in the core's order. The first one that matches wins. */
+export function classify(cli, lines) {
+    const data = DATA[cli];
+    if (!data)
+        return { kind: 'unknown' };
+    return classifyLines(data, windowOf(lines));
+}
+/** The composer alone. A running turn would otherwise hide an empty input box. */
+export function classifyComposer(cli, lines) {
+    const data = DATA[cli];
+    if (!data)
+        return { kind: 'unknown' };
+    return composeLines(data, windowOf(lines));
+}
+export function readScreen(cli, screen) {
+    if (screen === undefined)
+        return { kind: 'unknown' };
+    return classify(cli, screen.split('\n'));
+}

package/dist/worktree/place.d.ts

@@ -0,0 +1,18 @@
+import type { Seat, TeamFile } from '../file/types.ts';
+export declare function taskProblem(task: string): string | null;
+export declare function fillPattern(pattern: string, values: Record<string, string | undefined>): string | null;
+export declare function lobbyPath(team: Pick<TeamFile, 'project' | 'workspace'>): string | null;
+export declare function realLanding(root: string, folder: string): {
+    logical: string;
+    real: string;
+};
+/** Where a seat starts: the folder it waits in, or why it can't start. */
+export type SeatStart = {
+    cwd: string;
+    lobby?: true;
+} | {
+    problem: string;
+    once?: true;
+};
+export declare function seatStart(team: Pick<TeamFile, 'project' | 'workspace' | 'trust'>, seat: Seat, root: string): SeatStart;
+export declare function publicNameHit(team: Pick<TeamFile, 'visibility' | 'identity'>, names: string[]): string | null;

package/dist/worktree/place.js

@@ -0,0 +1,126 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { insideTrust, protectedBy } from "../file/paths.js";
+// A task name is one path segment. It is also the last segment of the folder and part of the branch.
+const TASK_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+export function taskProblem(task) {
+    if (!TASK_NAME.test(task)) {
+        return 'a task name is one segment of letters, digits, ".", "_" and "-", and it starts with a letter or a digit';
+    }
+    return null;
+}
+// Fills `{kind}` and `{task}`. Null when a placeholder has no value, or one is left that this command doesn't know.
+export function fillPattern(pattern, values) {
+    let unknown = false;
+    const filled = pattern.replace(/\{([^}]*)\}/g, (token, name) => {
+        const value = values[name];
+        if (value === undefined) {
+            unknown = true;
+            return token;
+        }
+        return value;
+    });
+    return unknown ? null : filled;
+}
+// The lobby: the neutral folder a seat that works in worktrees waits in until a brief names its
+// worktree — the folder the worktrees go in, with ".lobby" beside them, so a trust pattern that
+// covers the worktrees covers it too. Null when the file names no folder to take a parent from.
+export function lobbyPath(team) {
+    const path = team.workspace.path;
+    if (!path)
+        return null;
+    const parent = path.split('/').slice(0, -1).join('/').replaceAll('{repo}', team.project) || '.';
+    return join(parent, '.lobby');
+}
+// Where a folder will really land, `root` being the project root: `logical` is the path the file
+// names; `real` follows a symlink in an ancestor that already exists. The worktree command tests
+// both, and so does a seat's start: a worktrees folder that is a symlink into the project puts the
+// lobby — and any folder under it — physically inside the protected checkout.
+export function realLanding(root, folder) {
+    const logical = resolve(root, folder);
+    const tail = [];
+    let current = logical;
+    while (!existsSync(current)) {
+        const parent = dirname(current);
+        if (parent === current)
+            return { logical, real: logical };
+        tail.push(basename(current));
+        current = parent;
+    }
+    return { logical, real: join(realpathSync(current), ...tail.reverse()) };
+}
+// The protected checkout `folder` is in, in the text and then on disk: `protectedBy` reads the path
+// as written, then the folder and the checkouts are resolved — symlinks in the ancestors that exist
+// today followed — and tested again, so a folder that is physically inside one is inside it here.
+function protectedLanding(root, folder, checkouts) {
+    const written = protectedBy(folder, checkouts);
+    if (written)
+        return written;
+    const real = realLanding(root, folder).real;
+    for (const checkout of checkouts) {
+        const land = realLanding(root, checkout).real;
+        if (real === land || real.startsWith(`${land}${sep}`))
+            return checkout;
+    }
+    return null;
+}
+// Where a seat starts. A shared seat starts in the folder the file names — usually the project
+// root — and reads there. Every other seat starts outside every protected checkout: in the lobby
+// when the file gives it no folder of its own, or in the folder it names when that one is safe.
+// A folder is outside a checkout when it is outside it on disk too, symlinks resolved. `once` marks
+// a problem that is the same for every seat, so a caller says it once.
+export function seatStart(team, seat, root) {
+    if (seat.mode === 'shared')
+        return { cwd: seat.cwd };
+    if (seat.cwd !== '.') {
+        const hit = protectedLanding(root, seat.cwd, team.workspace.protected);
+        if (hit) {
+            return {
+                problem: `seat ${seat.name} would start in ${seat.cwd}, inside the protected checkout ${hit}; ` +
+                    "a seat that isn't `mode: shared` never starts in one",
+            };
+        }
+        return { cwd: seat.cwd };
+    }
+    const lobby = lobbyPath(team);
+    if (lobby === null) {
+        return {
+            problem: 'a seat that works in worktrees has no lobby to wait in: workspace.path must name the folder {task} goes under',
+            once: true,
+        };
+    }
+    const hit = protectedLanding(root, lobby, team.workspace.protected);
+    if (hit) {
+        return {
+            problem: `seat ${seat.name} would start in the lobby ${lobby}, inside the protected checkout ${hit}; ` +
+                "a seat that isn't `mode: shared` never starts in one",
+        };
+    }
+    if (!insideTrust(lobby, team.trust)) {
+        return {
+            problem: `the lobby ${lobby} matches no trust pattern (${team.trust.join(', ') || 'none'}): ` +
+                'add one that covers it and run `team approve`',
+            once: true,
+        };
+    }
+    return { cwd: lobby, lobby: true };
+}
+// The first name a public project's forbidden_public pattern matches, as "name matches pattern".
+export function publicNameHit(team, names) {
+    if (team.visibility !== 'public')
+        return null;
+    for (const source of team.identity.forbiddenPublic) {
+        let regex;
+        try {
+            regex = new RegExp(source);
+        }
+        catch (error) {
+            return `forbidden_public pattern ${JSON.stringify(source)} is not a regular expression: ${error.message}`;
+        }
+        for (const name of names) {
+            if (regex.test(name))
+                return `${JSON.stringify(name)} matches forbidden_public ${JSON.stringify(source)}`;
+        }
+    }
+    return null;
+}

package/dist/yaml.d.ts

@@ -0,0 +1,30 @@
+export type YamlScalar = string | number | boolean | null;
+export type YamlNode = {
+    kind: 'scalar';
+    line: number;
+    value: YamlScalar;
+    quoted: boolean;
+    raw: string;
+} | {
+    kind: 'seq';
+    line: number;
+    items: YamlNode[];
+} | {
+    kind: 'map';
+    line: number;
+    entries: YamlEntry[];
+};
+export type YamlEntry = {
+    key: string;
+    line: number;
+    value: YamlNode;
+};
+export type YamlValue = YamlScalar | YamlValue[] | {
+    [key: string]: YamlValue;
+};
+export declare class YamlError extends Error {
+    line: number;
+    constructor(line: number, message: string);
+}
+export declare function parseYaml(text: string): YamlNode;
+export declare function toValue(node: YamlNode): YamlValue;