copilot-operator 0.1.0

package/dist/src/context/projectMirror.js

@@ -0,0 +1,364 @@
+/**
+ * Mirrors selected parts of a project into one flat folder on the Desktop.
+ *
+ * Why flat, and why renamed. The folder is meant to sit inside a OneDrive-backed Desktop so
+ * the copies reach the cloud with no user action, and the chat's upload input rejects source
+ * extensions outright. So the directory structure cannot be kept as folders and the
+ * extensions cannot be kept as-is. Both problems are solved by encoding the path into the
+ * file name and giving everything a `.txt` tail:
+ *
+ *   src/test/example-test.spec.ts   ->   src--test--example-test.spec.ts.txt
+ *
+ * The convention is taken from the user's own Context Picker
+ * (https://github.com/ivan-markov-666/context-picker, MIT), specifically
+ * `copySelectionToDir` in `src/scan-core.ts`, so that a folder produced here and a folder
+ * produced by the extension are interchangeable:
+ *
+ *   - relative path, forward slashes, joined with the separator
+ *   - name collisions get `<sep><n>` appended, starting at 2, compared case-insensitively
+ *   - `.txt` appended last, after the collision suffix
+ *   - sync mode writes only files whose bytes differ and deletes what is no longer selected
+ *
+ * The difference from the extension is the input. There the user ticks individual files in
+ * an editor UI. Here the user names the project root and the directories to include, and
+ * selecting a directory takes everything beneath it.
+ */
+import { readFile, writeFile, readdir, stat, mkdir, rm } from 'node:fs/promises';
+import { join, relative, resolve, sep as osSep, basename, extname } from 'node:path';
+import ignore from 'ignore';
+/**
+ * Directories that are never useful as chat context, pruned at any depth even when there is
+ * no `.gitignore`. Same list as Context Picker's `DEFAULT_IGNORE`, plus the obvious
+ * JavaScript and Python build output.
+ */
+export const DEFAULT_IGNORE_DIRS = [
+    'node_modules',
+    '.git',
+    'bin',
+    'obj',
+    '.vs',
+    '.idea',
+    'dist',
+    'build',
+    'out',
+    'coverage',
+    '__pycache__',
+    '.venv',
+    'venv',
+    'target',
+];
+export const DEFAULT_SEPARATOR = '--';
+export const DEFAULT_MAX_FILE_BYTES = 2 * 1024 * 1024;
+/** `.\Src\Foo\` and `src/foo` are the same directory. This is the form both lists compare in. */
+export function normalizeDirPath(dir) {
+    const cleaned = dir
+        .trim()
+        .replace(/\\/g, '/')
+        .replace(/^\.\//, '')
+        .replace(/\/+$/, '');
+    return cleaned === '' ? '.' : cleaned;
+}
+function isUnder(child, parent) {
+    if (parent === '.')
+        return child !== '.';
+    return child.toLowerCase().startsWith(`${parent.toLowerCase()}/`);
+}
+/** Every contradiction between the two lists, so a UI can refuse to save and say why. */
+export function findSelectionConflicts(includeDirs, excludeDirs) {
+    const includes = includeDirs.map(normalizeDirPath).filter(Boolean);
+    const excludes = excludeDirs.map(normalizeDirPath).filter(Boolean);
+    const out = [];
+    for (const inc of includes) {
+        for (const exc of excludes) {
+            if (inc.toLowerCase() === exc.toLowerCase()) {
+                out.push({ include: inc, exclude: exc, kind: 'same' });
+            }
+            else if (isUnder(inc, exc)) {
+                out.push({ include: inc, exclude: exc, kind: 'excluded-parent' });
+            }
+        }
+    }
+    return out;
+}
+/** One sentence per conflict, for a message box or a thrown error. */
+export function describeConflicts(conflicts) {
+    return conflicts
+        .map((c) => c.kind === 'same'
+        ? `"${c.include}" is in both the include and the exclude list.`
+        : `"${c.exclude}" is excluded but "${c.include}" is included, and lies under it.`)
+        .join(' ');
+}
+/** Files the program owns in the target folder and must never delete as "stale". */
+const RESERVED_TARGET_NAMES = new Set(['.cop-manifest.json']);
+/**
+ * Files that hold secrets by convention, never copied to the Desktop unless the operator says so.
+ * `.env` was the only one until 2026-09-27; a key file, an `.npmrc` with a registry token or a
+ * `credentials.json` are secrets just the same, and the Desktop is on its way to OneDrive.
+ */
+function isEnvFile(path) {
+    const name = basename(path).toLowerCase();
+    if (name === '.env' || name.startsWith('.env.'))
+        return true;
+    if (/\.(pem|pfx|p12|key|jks|keystore|kdbx|ppk)$/.test(name))
+        return true;
+    if (/^id_(rsa|dsa|ecdsa|ed25519)(\.pub)?$/.test(name))
+        return true;
+    return ['.npmrc', '.netrc', '.pypirc', 'credentials.json', 'secrets.json', 'service-account.json', '.htpasswd'].includes(name)
+        || /(^|\.)secrets?\.(json|ya?ml|toml|xml)$/.test(name);
+}
+/**
+ * Flattens a relative path into a single file name.
+ *
+ * `used` carries the names already taken, lower-cased, and is mutated. Collisions are
+ * possible because two different paths can flatten to the same string once separators are
+ * substituted, so the suffix is not optional.
+ */
+export function flattenName(relPath, used, separator = DEFAULT_SEPARATOR, txtMode = 'append') {
+    const normalized = relPath.split(/[\\/]/).join(separator);
+    let candidate = normalized;
+    let i = 2;
+    while (used.has(candidate.toLowerCase())) {
+        candidate = `${normalized}${separator}${i}`;
+        i += 1;
+    }
+    used.add(candidate.toLowerCase());
+    switch (txtMode) {
+        case 'append':
+            return `${candidate}.txt`;
+        case 'replace': {
+            const ext = extname(candidate);
+            return ext ? `${candidate.slice(0, -ext.length)}.txt` : `${candidate}.txt`;
+        }
+        case 'none':
+            return candidate;
+    }
+}
+async function loadGitignore(rootDir, respect) {
+    if (!respect)
+        return null;
+    try {
+        const content = await readFile(join(rootDir, '.gitignore'), 'utf8');
+        return ignore().add(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Depth-first walk of one directory, returning file paths relative to `rootDir`.
+ *
+ * Two rules about `.env` files are enforced here, and nowhere else:
+ *
+ *   - `.gitignore` never decides an env file. Almost every project ignores `.env`, so letting
+ *     the gitignore option hide them would make the env option meaningless. Env files are
+ *     always handed to `collectFiles`, which keeps or drops them by the env option alone.
+ *   - When env files are wanted, a directory that only `.gitignore` hides is still descended
+ *     into, but nothing except env files is taken from it. That is how an env file inside an
+ *     ignored folder still reaches the selection without dragging the folder along with it.
+ *
+ * `DEFAULT_IGNORE_DIRS` and the user's own exclusions are absolute: they are never descended
+ * into, env files or not.
+ */
+async function walk(rootDir, dirRel, ig, ignoreDirs, excluded, out, opts) {
+    const abs = join(rootDir, dirRel);
+    let entries;
+    try {
+        entries = await readdir(abs, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const childRel = dirRel === '.' ? entry.name : `${dirRel}/${entry.name}`;
+        const posixRel = childRel.split(osSep).join('/');
+        if (entry.isDirectory()) {
+            if (ignoreDirs.has(entry.name.toLowerCase()))
+                continue;
+            if (excluded.has(posixRel.toLowerCase()))
+                continue;
+            const gitignored = opts.inGitignored === true || (ig?.ignores(`${posixRel}/`) ?? false);
+            if (gitignored && !opts.includeEnvFiles)
+                continue;
+            await walk(rootDir, childRel, ig, ignoreDirs, excluded, out, { ...opts, inGitignored: gitignored });
+        }
+        else if (entry.isFile()) {
+            if (isEnvFile(entry.name)) {
+                out.push(posixRel);
+                continue;
+            }
+            if (opts.inGitignored)
+                continue;
+            if (ig?.ignores(posixRel))
+                continue;
+            out.push(posixRel);
+        }
+    }
+}
+/**
+ * Lists the directories under `rootDir` that are worth offering for selection, so a CLI or
+ * a UI can present the same kind of choice the extension's checkbox tree does. Pruned by the
+ * same rules as the mirror itself, so what is listed is what can actually be copied.
+ */
+export async function listSelectableDirs(rootDir, opts = {}) {
+    const ig = await loadGitignore(resolve(rootDir), opts.respectGitignore ?? true);
+    const ignoreDirs = new Set([...DEFAULT_IGNORE_DIRS, ...(opts.ignoreDirs ?? [])].map((d) => d.toLowerCase()));
+    const maxDepth = opts.maxDepth ?? 4;
+    const found = [];
+    const recurse = async (dirRel, depth) => {
+        if (depth > maxDepth)
+            return;
+        let entries;
+        try {
+            entries = await readdir(join(resolve(rootDir), dirRel), { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (ignoreDirs.has(entry.name.toLowerCase()))
+                continue;
+            const childRel = dirRel === '.' ? entry.name : `${dirRel}/${entry.name}`;
+            if (ig?.ignores(`${childRel}/`))
+                continue;
+            found.push(childRel);
+            await recurse(childRel, depth + 1);
+        }
+    };
+    await recurse('.', 1);
+    return found.sort();
+}
+/**
+ * Collects the files the configuration selects, as paths relative to `rootDir`, sorted and
+ * de-duplicated. Exported separately so a caller can preview a selection without writing
+ * anything.
+ */
+export async function collectFiles(cfg) {
+    const rootDir = resolve(cfg.rootDir);
+    if (cfg.includeDirs.length === 0) {
+        throw new Error('includeDirs is empty: nothing would be copied. Select at least one directory.');
+    }
+    const conflicts = findSelectionConflicts(cfg.includeDirs, cfg.excludeDirs ?? []);
+    if (conflicts.length > 0) {
+        throw new Error(`The include and exclude lists contradict each other. ${describeConflicts(conflicts)}`);
+    }
+    const includeEnvFiles = cfg.includeEnvFiles ?? false;
+    const ig = await loadGitignore(rootDir, cfg.respectGitignore ?? true);
+    const ignoreDirs = new Set([...DEFAULT_IGNORE_DIRS, ...(cfg.ignoreDirs ?? [])].map((d) => d.toLowerCase()));
+    const excluded = new Set((cfg.excludeDirs ?? []).map((d) => normalizeDirPath(d).toLowerCase()));
+    const collected = new Set();
+    const skipped = [];
+    for (const dir of cfg.includeDirs) {
+        const dirRel = normalizeDirPath(dir);
+        const abs = join(rootDir, dirRel);
+        const s = await stat(abs).catch(() => null);
+        if (!s?.isDirectory()) {
+            skipped.push({ relPath: dirRel, reason: 'not a directory under the project root' });
+            continue;
+        }
+        const found = [];
+        await walk(rootDir, dirRel, ig, ignoreDirs, excluded, found, { includeEnvFiles });
+        for (const f of found)
+            collected.add(f);
+    }
+    const maxBytes = cfg.maxFileBytes ?? DEFAULT_MAX_FILE_BYTES;
+    const files = [];
+    for (const rel of [...collected].sort()) {
+        if (!includeEnvFiles && isEnvFile(rel)) {
+            skipped.push({ relPath: rel, reason: 'env file, excluded to protect secrets' });
+            continue;
+        }
+        const s = await stat(join(rootDir, rel)).catch(() => null);
+        if (!s)
+            continue;
+        if (s.size > maxBytes) {
+            skipped.push({ relPath: rel, reason: `larger than ${Math.round(maxBytes / 1024)} KB` });
+            continue;
+        }
+        files.push(rel);
+    }
+    return { files, skipped };
+}
+/**
+ * Brings `targetDir` in line with the selection.
+ *
+ * Incremental by construction: a file is written only when its bytes differ from what is
+ * already there, and target files that are no longer part of the selection are deleted.
+ * Unchanged files are left untouched, which is what keeps OneDrive from re-uploading a whole
+ * project every time one file is edited.
+ */
+export async function mirrorProject(cfg) {
+    const rootDir = resolve(cfg.rootDir);
+    const targetDir = resolve(cfg.targetDir);
+    const separator = cfg.separator ?? DEFAULT_SEPARATOR;
+    const txtMode = cfg.txtMode ?? 'append';
+    const { files, skipped } = await collectFiles(cfg);
+    await mkdir(targetDir, { recursive: true });
+    const used = new Set();
+    const desired = new Set();
+    const mapping = {};
+    const added = [];
+    const updated = [];
+    const unchanged = [];
+    let totalBytes = 0;
+    for (const rel of files) {
+        const targetName = flattenName(cfg.namePrefix ? `${cfg.namePrefix}/${rel}` : rel, used, separator, txtMode);
+        desired.add(targetName);
+        mapping[rel] = targetName;
+        const source = join(rootDir, rel);
+        const dest = join(targetDir, targetName);
+        const bytes = await readFile(source);
+        totalBytes += bytes.length;
+        const existing = await readFile(dest).catch(() => null);
+        if (existing === null) {
+            await writeFile(dest, bytes);
+            added.push(targetName);
+        }
+        else if (existing.equals(bytes)) {
+            unchanged.push(targetName);
+        }
+        else {
+            await writeFile(dest, bytes);
+            updated.push(targetName);
+        }
+    }
+    const deleted = [];
+    for (const entry of await readdir(targetDir).catch(() => [])) {
+        if (desired.has(entry) || RESERVED_TARGET_NAMES.has(entry))
+            continue;
+        await rm(join(targetDir, entry), { recursive: true, force: true });
+        deleted.push(entry);
+    }
+    return {
+        added: added.sort(),
+        updated: updated.sort(),
+        deleted: deleted.sort(),
+        unchanged: unchanged.sort(),
+        skipped,
+        mapping,
+        totalBytes,
+    };
+}
+/** One line for the console and the run log. */
+export function describeMirror(r) {
+    const bits = [
+        `${r.added.length} added`,
+        `${r.updated.length} updated`,
+        `${r.deleted.length} deleted`,
+        `${r.unchanged.length} unchanged`,
+    ];
+    if (r.skipped.length)
+        bits.push(`${r.skipped.length} skipped`);
+    return bits.join(', ');
+}
+/** Recovers the original relative path from a mirrored file name. */
+export function unflattenName(targetName, separator = DEFAULT_SEPARATOR, txtMode = 'append') {
+    let name = targetName;
+    if (txtMode === 'append' && name.toLowerCase().endsWith('.txt')) {
+        name = name.slice(0, -4);
+    }
+    return name.split(separator).join('/');
+}
+/** `relative()` re-exported for callers building configs from absolute paths. */
+export { relative as relativePath };

package/dist/src/exec/authorizer.js

@@ -0,0 +1,61 @@
+import { staticCheck, describeStep } from './policy.js';
+import { networkFetchReason, networkFetchRefusal } from './network.js';
+import { scriptNetworkReason } from './policy.js';
+import { createInterface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+/**
+ * Runs the static rules, then, unless unattended, asks the human through `ask`.
+ *
+ * A step that fetches from the network is the exception to "unless unattended": it is asked about
+ * in every mode, with `held` saying why, because the runs nobody is watching are exactly the ones
+ * in which a download followed by a second step that runs it would otherwise go unseen. `cfg` is
+ * read on every call, not captured, so a run switched to unattended half-way is judged as one from
+ * its next step on.
+ */
+export function makeAuthorizer(cfg, ask) {
+    return {
+        async authorize(step, ctx) {
+            const blocked = staticCheck(step, cfg, undefined, ctx.confinement);
+            if (blocked)
+                return blocked;
+            const cwd = ctx.confinement?.cwd;
+            const network = networkFetchReason(step.cmd, cwd) ?? (cwd ? scriptNetworkReason(step.cmd, cwd) : null);
+            if (network)
+                return await ask(step, ctx, { network });
+            if (cfg.mode === 'unattended')
+                return { action: 'run' };
+            return await ask(step, ctx);
+        },
+    };
+}
+/** The terminal version: Enter runs, `s` skips, `q` aborts. */
+export function terminalAuthorizer(cfg, print) {
+    return makeAuthorizer(cfg, async (step, _ctx, held) => {
+        print('');
+        print(`  step ${step.id}: ${describeStep(step)}`);
+        if (held)
+            print(`  held: ${held.network}`);
+        const rl = createInterface({ input: stdin, output: stdout });
+        try {
+            const answer = (await rl.question('  [Enter] run  [s] skip  [q] abort > ')).trim().toLowerCase();
+            if (answer === 'q')
+                return { action: 'abort', reason: 'aborted by the operator' };
+            if (answer === 's')
+                return { action: 'skip', reason: 'skipped by the operator' };
+            return { action: 'run' };
+        }
+        finally {
+            rl.close();
+        }
+    });
+}
+/**
+ * Everything runs after the static rules. Only for runs the user explicitly marked so.
+ *
+ * A step held for a person (a network fetch) is refused here, with the reason, because this form
+ * has nobody to ask. The web UI does not use it: its unattended runs keep the approval screen for
+ * exactly those steps.
+ */
+export function unattendedAuthorizer(cfg) {
+    return makeAuthorizer({ ...cfg, mode: 'unattended' }, async (_step, _ctx, held) => held ? { action: 'skip', reason: networkFetchRefusal(held.network) } : { action: 'run' });
+}