icopilot 2.2.0

package/dist/tools/web.js

@@ -0,0 +1,167 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const DEFAULT_POLICY = { allow: [], deny: [], defaultAllow: false };
+const DEFAULT_MAX_BYTES = 200_000;
+const TIMEOUT_MS = 10_000;
+export function loadPolicy() {
+    const policyPath = path.join(os.homedir(), '.icopilot', 'web-policy.json');
+    if (!fs.existsSync(policyPath))
+        return { ...DEFAULT_POLICY };
+    try {
+        const parsed = JSON.parse(fs.readFileSync(policyPath, 'utf8'));
+        return {
+            allow: Array.isArray(parsed.allow) ? parsed.allow.filter(isString) : [],
+            deny: Array.isArray(parsed.deny) ? parsed.deny.filter(isString) : [],
+            defaultAllow: typeof parsed.defaultAllow === 'boolean' ? parsed.defaultAllow : false,
+        };
+    }
+    catch {
+        return { ...DEFAULT_POLICY };
+    }
+}
+export function hostAllowed(host, policy) {
+    const normalizedHost = normalizeHost(host);
+    if (!normalizedHost)
+        return false;
+    if (policy.deny.some((entry) => hostMatches(normalizedHost, entry)))
+        return false;
+    if (policy.allow.some((entry) => hostMatches(normalizedHost, entry)))
+        return true;
+    return policy.defaultAllow;
+}
+export async function webFetchTool(args) {
+    try {
+        const url = new URL(args.url);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+            return JSON.stringify({ ok: false, error: `unsupported protocol: ${url.protocol}` });
+        }
+        const host = url.hostname;
+        if (!hostAllowed(host, loadPolicy())) {
+            return JSON.stringify({
+                ok: false,
+                error: `host not allowed by web fetch policy: ${host}`,
+            });
+        }
+        const maxBytes = normalizeMaxBytes(args.maxBytes);
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+        try {
+            const response = await fetch(url, {
+                headers: sanitizeHeaders(args.headers),
+                signal: controller.signal,
+            });
+            const { bytes, text } = await readText(response, maxBytes);
+            return JSON.stringify({
+                ok: true,
+                status: response.status,
+                contentType: getContentType(response),
+                bytes,
+                text,
+            });
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    catch (e) {
+        return JSON.stringify({ ok: false, error: e?.message || String(e) });
+    }
+}
+export const WEB_FETCH_SCHEMA = {
+    type: 'function',
+    function: {
+        name: 'web_fetch',
+        description: 'Fetch an HTTP(S) web page only when its host is allowed by the user-managed host allowlist.',
+        parameters: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'HTTP or HTTPS URL to fetch.' },
+                maxBytes: {
+                    type: 'number',
+                    default: DEFAULT_MAX_BYTES,
+                    description: 'Maximum response bytes to read before truncating.',
+                },
+                headers: {
+                    type: 'object',
+                    additionalProperties: { type: 'string' },
+                    description: 'Optional request headers.',
+                },
+            },
+            required: ['url'],
+        },
+    },
+};
+function hostMatches(host, entry) {
+    const normalizedEntry = normalizeHost(entry);
+    if (!normalizedEntry)
+        return false;
+    if (normalizedEntry.startsWith('*.')) {
+        const suffix = normalizedEntry.slice(1);
+        return host.endsWith(suffix) && host.length > suffix.length;
+    }
+    return host === normalizedEntry;
+}
+function normalizeHost(host) {
+    return host.trim().toLowerCase().replace(/\.$/, '');
+}
+function normalizeMaxBytes(maxBytes) {
+    if (typeof maxBytes !== 'number' || !Number.isFinite(maxBytes))
+        return DEFAULT_MAX_BYTES;
+    return Math.max(0, Math.floor(maxBytes));
+}
+function sanitizeHeaders(headers) {
+    if (!headers)
+        return undefined;
+    return Object.fromEntries(Object.entries(headers).filter((entry) => isString(entry[1])));
+}
+async function readText(response, maxBytes) {
+    if (!response.body) {
+        const responseLike = response;
+        const buffer = typeof response.arrayBuffer === 'function'
+            ? new Uint8Array(await response.arrayBuffer())
+            : new TextEncoder().encode(typeof responseLike.text === 'function' ? await responseLike.text() : '');
+        const slice = buffer.slice(0, maxBytes);
+        return { bytes: slice.byteLength, text: new TextDecoder().decode(slice) };
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let bytes = 0;
+    let reachedLimit = maxBytes === 0;
+    try {
+        while (bytes < maxBytes) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            const remaining = maxBytes - bytes;
+            const chunk = value.byteLength > remaining ? value.slice(0, remaining) : value;
+            chunks.push(chunk);
+            bytes += chunk.byteLength;
+            if (bytes >= maxBytes) {
+                reachedLimit = true;
+                break;
+            }
+        }
+    }
+    finally {
+        if (reachedLimit)
+            await reader.cancel();
+        reader.releaseLock();
+    }
+    return { bytes, text: new TextDecoder().decode(concatChunks(chunks, bytes)) };
+}
+function getContentType(response) {
+    return response.headers?.get?.('content-type') ?? '';
+}
+function concatChunks(chunks, bytes) {
+    const buffer = new Uint8Array(bytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return buffer;
+}
+function isString(value) {
+    return typeof value === 'string';
+}

package/dist/ui/prompt.js

@@ -0,0 +1,37 @@
+import readline from 'node:readline';
+import { theme } from './theme.js';
+import { attachKeybindings, applyKeybindingConfig, } from '../util/keybindings.js';
+/** Minimal readline-based prompt (history-enabled, with optional keybindings). */
+export function createPrompt(keybindingMode) {
+    const mode = keybindingMode ?? applyKeybindingConfig();
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+        // Future DX: path completion can be added here without changing callers.
+        historySize: 500,
+    });
+    // Attach keybindings if configured
+    if (mode !== 'default') {
+        attachKeybindings(rl, mode);
+    }
+    return {
+        read(prompt) {
+            return new Promise((resolve) => {
+                rl.question(prompt, (answer) => resolve(answer));
+            });
+        },
+        close() {
+            rl.close();
+        },
+        getKeybindingMode() {
+            return mode;
+        },
+    };
+}
+export function prefix(mode) {
+    const safeUnicode = process.platform !== 'win32' || Boolean(process.env.WT_SESSION);
+    const label = mode === 'plan' ? 'Plan' : 'Copilot';
+    const tag = safeUnicode ? theme.badge(label) : `[${label}]`;
+    return `${tag} ${theme.user(safeUnicode ? '›' : '>')} `;
+}

package/dist/ui/render.js

@@ -0,0 +1,96 @@
+import { theme } from './theme.js';
+import { lazy } from '../util/lazy.js';
+let markdownConfigured = false;
+const loadMarked = lazy(async () => import('marked'));
+const loadTerminalRenderer = lazy(async () => (await import('marked-terminal')).default);
+export async function ensureMarkdown() {
+    const [{ marked }, TerminalRenderer] = await Promise.all([loadMarked(), loadTerminalRenderer()]);
+    if (markdownConfigured) {
+        return { parse: (md) => marked.parse(md) };
+    }
+    marked.setOptions({
+        // @ts-expect-error — marked-terminal's renderer is compatible at runtime.
+        renderer: new TerminalRenderer({
+            reflowText: false,
+            showSectionPrefix: false,
+            tab: 2,
+            codespan: theme.hl,
+        }),
+    });
+    markdownConfigured = true;
+    return { parse: (md) => marked.parse(md) };
+}
+/** Streaming sink: prints raw tokens with mild styling for low-latency feel.
+ *  Tracks fenced ``` code blocks across token boundaries and renders the
+ *  inside of a fence in `theme.hl` so the user can visually distinguish code
+ *  from prose during streaming, without waiting for the full markdown render. */
+export class StreamSink {
+    buf = '';
+    inCode = false;
+    lineBuf = '';
+    write(token) {
+        this.buf += token;
+        for (const ch of token) {
+            this.lineBuf += ch;
+            if (ch === '\n') {
+                this.flushLine();
+            }
+        }
+    }
+    flushLine() {
+        const line = this.lineBuf;
+        this.lineBuf = '';
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith('```')) {
+            // toggle on the fence boundary; print fence dimmed
+            this.inCode = !this.inCode;
+            process.stdout.write(theme.dim(line));
+            return;
+        }
+        if (this.inCode) {
+            process.stdout.write(theme.hl(line));
+            return;
+        }
+        process.stdout.write(line);
+    }
+    /** After completion, optionally re-render fenced markdown for a polished view. */
+    finalize() {
+        if (this.lineBuf) {
+            // flush any trailing partial line
+            const tail = this.lineBuf;
+            this.lineBuf = '';
+            if (this.inCode)
+                process.stdout.write(theme.hl(tail));
+            else
+                process.stdout.write(tail);
+        }
+        process.stdout.write('\n');
+        return this.buf;
+    }
+    /** Render captured markdown buffer as styled terminal output. */
+    async renderMarkdown() {
+        if (!this.buf.trim())
+            return;
+        try {
+            const markdown = await ensureMarkdown();
+            const rendered = markdown.parse(this.buf).trimEnd();
+            process.stdout.write(theme.dim('─'.repeat(60)) + '\n');
+            process.stdout.write(rendered + '\n');
+        }
+        catch {
+            /* fall back silently — raw stream already shown */
+        }
+    }
+    text() {
+        return this.buf;
+    }
+}
+export async function renderMarkdownString(md) {
+    try {
+        const markdown = await ensureMarkdown();
+        return markdown.parse(md).trimEnd();
+    }
+    catch {
+        return md;
+    }
+}

package/dist/ui/screen.js

@@ -0,0 +1,13 @@
+export const ESC = '\x1b[';
+export const altScreenEnter = () => process.stdout.write('\x1b[?1049h');
+export const altScreenExit = () => process.stdout.write('\x1b[?1049l');
+export const clear = () => process.stdout.write('\x1b[2J\x1b[H');
+export const moveTo = (row, col) => process.stdout.write(`\x1b[${row};${col}H`);
+export const hideCursor = () => process.stdout.write('\x1b[?25l');
+export const showCursor = () => process.stdout.write('\x1b[?25h');
+export function size() {
+    return {
+        rows: process.stdout.rows || 24,
+        cols: process.stdout.columns || 80,
+    };
+}

package/dist/ui/theme.js

@@ -0,0 +1,56 @@
+import chalk, { Chalk, supportsColor } from 'chalk';
+import { config } from '../config.js';
+const plain = (text) => text;
+function colorEnabled() {
+    if (config.theme === 'none')
+        return false;
+    if (process.env.FORCE_COLOR !== undefined)
+        return true;
+    if (process.env.NO_COLOR)
+        return false;
+    if (!process.stdout.isTTY)
+        return false;
+    if (process.env.CI)
+        return false;
+    return Boolean(supportsColor || chalk.level > 0);
+}
+function palette() {
+    const c = colorEnabled() ? chalk : new Chalk({ level: 0 });
+    return { c, name: config.theme === 'light' ? 'light' : 'dark' };
+}
+function style(fn) {
+    return (text) => {
+        if (!colorEnabled())
+            return text;
+        const p = palette();
+        return fn(p.c, p.name)(text);
+    };
+}
+export function selectTheme() {
+    return config.theme;
+}
+export const theme = {
+    brand: style((c, name) => (name === 'light' ? c.hex('#0F6CBD').bold : c.hex('#58A6FF').bold)),
+    user: style((c, name) => (name === 'light' ? c.hex('#0F6CBD').bold : c.hex('#58A6FF').bold)),
+    assistant: style((c, name) => (name === 'light' ? c.green.bold : c.green)),
+    system: style((c) => c.gray.italic),
+    warn: style((c, name) => (name === 'light' ? c.hex('#92400E') : c.yellow)),
+    err: style((c) => c.red.bold),
+    ok: style((c, name) => (name === 'light' ? c.hex('#166534').bold : c.green.bold)),
+    dim: style((c) => c.gray),
+    hl: style((c, name) => (name === 'light' ? c.hex('#0A5CA8') : c.hex('#79C0FF'))),
+    badge: (s) => {
+        if (!colorEnabled())
+            return ` ${s} `;
+        const p = palette();
+        return p.name === 'light'
+            ? p.c.bgHex('#0F6CBD').white.bold(` ${s} `)
+            : p.c.bgHex('#1F6FEB').white.bold(` ${s} `);
+    },
+};
+export function banner(version, model) {
+    const title = theme.brand('GitHub Copilot');
+    const sep = colorEnabled() ? '•' : '-';
+    const sub = theme.dim(`v${version}  ${sep}  model: ${theme.hl(model)}`);
+    return `\n${title}  ${sub}\n${theme.dim('Type /help for commands. @file to inject a file. Ctrl-C to interrupt.')}\n`;
+}

package/dist/util/browser.js

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process';
+export async function openBrowser(url, spawnImpl = spawn) {
+    const platform = process.platform;
+    const { command, args } = resolveBrowserCommand(platform, url);
+    await new Promise((resolve, reject) => {
+        const child = spawnImpl(command, args, {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        const proc = child;
+        proc.once('error', reject);
+        proc.unref?.();
+        resolve();
+    });
+}
+export function resolveBrowserCommand(platform, url) {
+    if (platform === 'win32') {
+        return {
+            command: 'cmd',
+            args: ['/c', 'start', '', url],
+        };
+    }
+    if (platform === 'darwin') {
+        return {
+            command: 'open',
+            args: [url],
+        };
+    }
+    return {
+        command: 'xdg-open',
+        args: [url],
+    };
+}