@termaxjs/web-ai 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./lib/index.js";
+export * from "./tools/tools.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./types.js";
+export * from "./config.js";
+export * from "./lib/index.js";
+export * from "./tools/tools.js";

package/dist/lib/compact.d.ts

@@ -0,0 +1,8 @@
+import type { ModelMessage } from "ai";
+export type CompactResult = {
+    messages: ModelMessage[];
+    compacted: boolean;
+    droppedCount: number;
+};
+export declare function compactModelMessages(messages: ModelMessage[], contextLimit: number): ModelMessage[];
+export declare function compactModelMessagesDetailed(messages: ModelMessage[], contextLimit: number): CompactResult;

package/dist/lib/compact.js

@@ -0,0 +1,179 @@
+const KEEP_TAIL = 24;
+const ELISION_TEXT = "[elided to save context — see prior tool call in history]";
+function approxBytes(messages) {
+    let n = 0;
+    for (const m of messages) {
+        if (typeof m.content === "string")
+            n += m.content.length;
+        else if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === "text" && typeof part.text === "string")
+                    n += part.text.length;
+                else if (part.type === "tool-result")
+                    n += JSON.stringify(part.output ?? "").length;
+                else if (part.type === "tool-call")
+                    n += JSON.stringify(part.input ?? "").length;
+                else
+                    n += 64;
+            }
+        }
+    }
+    return n;
+}
+function elideToolResult(part) {
+    if (part.type !== "tool-result")
+        return { changed: false, part };
+    if (part.output &&
+        typeof part.output === "object" &&
+        part.output.__elided) {
+        return { changed: false, part };
+    }
+    return {
+        changed: true,
+        part: {
+            ...part,
+            output: { type: "text", value: ELISION_TEXT, __elided: true },
+        },
+    };
+}
+function pathOfInput(input) {
+    if (!input || typeof input !== "object")
+        return null;
+    const p = input.path;
+    return typeof p === "string" && p.length > 0 ? p : null;
+}
+function collectMutationPaths(messages) {
+    const paths = new Set();
+    for (const m of messages) {
+        if (!Array.isArray(m.content))
+            continue;
+        for (const part of m.content) {
+            if (part.type !== "tool-call")
+                continue;
+            const name = part.toolName;
+            if (name === "edit" ||
+                name === "multi_edit" ||
+                name === "write_file" ||
+                name === "create_directory") {
+                const p = pathOfInput(part.input);
+                if (p)
+                    paths.add(p);
+            }
+        }
+    }
+    return paths;
+}
+function collectLastReadIdxPerPath(messages) {
+    const lastIdx = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (!Array.isArray(m.content))
+            continue;
+        for (const part of m.content) {
+            if (part.type !== "tool-call")
+                continue;
+            if (part.toolName !== "read_file")
+                continue;
+            const p = pathOfInput(part.input);
+            if (p)
+                lastIdx.set(p, i);
+        }
+    }
+    return lastIdx;
+}
+function dropSupersededReads(messages) {
+    const mutated = collectMutationPaths(messages);
+    const lastReadIdx = collectLastReadIdxPerPath(messages);
+    const callIdxToPath = new Map();
+    for (let i = 0; i < messages.length; i++) {
+        const m = messages[i];
+        if (!Array.isArray(m.content))
+            continue;
+        for (const part of m.content) {
+            if (part.type !== "tool-call" || part.toolName !== "read_file")
+                continue;
+            const p = pathOfInput(part.input);
+            const id = part.toolCallId;
+            if (p && typeof id === "string")
+                callIdxToPath.set(id, p);
+        }
+    }
+    let touched = false;
+    const out = messages.map((m, i) => {
+        if (!Array.isArray(m.content))
+            return m;
+        let local = false;
+        const nextContent = m.content.map((part) => {
+            if (part.type !== "tool-result")
+                return part;
+            const id = part.toolCallId;
+            if (typeof id !== "string")
+                return part;
+            const path = callIdxToPath.get(id);
+            if (!path)
+                return part;
+            const isStale = mutated.has(path) ||
+                (lastReadIdx.has(path) && lastReadIdx.get(path) > i);
+            if (!isStale)
+                return part;
+            const r = elideToolResult(part);
+            if (r.changed)
+                local = true;
+            return r.part;
+        });
+        if (!local)
+            return m;
+        touched = true;
+        return { ...m, content: nextContent };
+    });
+    return { out, touched };
+}
+export function compactModelMessages(messages, contextLimit) {
+    return compactModelMessagesDetailed(messages, contextLimit).messages;
+}
+export function compactModelMessagesDetailed(messages, contextLimit) {
+    let dropped = 0;
+    let working = messages;
+    let approxTokens = approxBytes(working) / 4;
+    if (approxTokens >= 0.55 * contextLimit) {
+        const r = dropSupersededReads(working);
+        if (r.touched) {
+            working = r.out;
+            dropped++;
+            approxTokens = approxBytes(working) / 4;
+        }
+    }
+    if (approxTokens < 0.7 * contextLimit) {
+        return {
+            messages: working,
+            compacted: dropped > 0,
+            droppedCount: dropped,
+        };
+    }
+    const out = working.slice();
+    const stopIdx = Math.max(0, out.length - KEEP_TAIL);
+    for (let i = 0; i < stopIdx; i++) {
+        if (out[i].role === "system")
+            continue;
+        if (!Array.isArray(out[i].content))
+            continue;
+        let local = false;
+        const next = out[i].content.map((part) => {
+            const r = elideToolResult(part);
+            if (r.changed)
+                local = true;
+            return r.part;
+        });
+        if (local) {
+            out[i] = { ...out[i], content: next };
+            dropped++;
+            if (approxBytes(out) / 4 < 0.6 * contextLimit)
+                break;
+        }
+    }
+    return {
+        messages: out,
+        compacted: dropped > 0,
+        droppedCount: dropped,
+    };
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./security.js";
+export * from "./compact.js";
+export * from "./redact.js";
+export * from "./miniWindowGeometry.js";

package/dist/lib/index.js

@@ -0,0 +1,4 @@
+export * from "./security.js";
+export * from "./compact.js";
+export * from "./redact.js";
+export * from "./miniWindowGeometry.js";

package/dist/lib/miniWindowGeometry.d.ts

@@ -0,0 +1,17 @@
+export type Geom = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export type Viewport = {
+    vw: number;
+    vh: number;
+};
+export type ResizeDir = "n" | "s" | "e" | "w" | "ne" | "nw" | "se" | "sw";
+export declare const MIN_W = 400;
+export declare const MIN_H = 280;
+export declare function defaultGeom(vp: Viewport): Geom;
+export declare function clampGeom(g: Geom, vp: Viewport): Geom;
+export declare function applyDrag(start: Geom, dx: number, dy: number, vp: Viewport): Geom;
+export declare function applyResize(start: Geom, dir: ResizeDir, dx: number, dy: number, vp: Viewport): Geom;

package/dist/lib/miniWindowGeometry.js

@@ -0,0 +1,59 @@
+export const MIN_W = 400;
+export const MIN_H = 280;
+const MARGIN_X = 16;
+const BOTTOM_GAP = 96;
+const TOP_GAP = 16;
+const clamp = (v, lo, hi) => v < lo ? lo : v > hi ? hi : v;
+export function defaultGeom(vp) {
+    const w = Math.max(MIN_W, Math.min(500, vp.vw - MARGIN_X * 2));
+    const h = Math.max(MIN_H, Math.min(600, vp.vh - BOTTOM_GAP - TOP_GAP));
+    return clampGeom({ x: vp.vw - w - MARGIN_X, y: vp.vh - h - BOTTOM_GAP, w, h }, vp);
+}
+export function clampGeom(g, vp) {
+    const w = clamp(g.w, MIN_W, Math.max(MIN_W, vp.vw));
+    const h = clamp(g.h, MIN_H, Math.max(MIN_H, vp.vh));
+    return {
+        w,
+        h,
+        x: clamp(g.x, 0, Math.max(0, vp.vw - w)),
+        y: clamp(g.y, 0, Math.max(0, vp.vh - h)),
+    };
+}
+export function applyDrag(start, dx, dy, vp) {
+    return clampGeom({ ...start, x: start.x + dx, y: start.y + dy }, vp);
+}
+export function applyResize(start, dir, dx, dy, vp) {
+    let left = start.x;
+    let top = start.y;
+    let right = start.x + start.w;
+    let bottom = start.y + start.h;
+    const movesW = dir.includes("w");
+    const movesE = dir.includes("e");
+    const movesN = dir.includes("n");
+    const movesS = dir.includes("s");
+    if (movesE)
+        right += dx;
+    if (movesW)
+        left += dx;
+    if (movesS)
+        bottom += dy;
+    if (movesN)
+        top += dy;
+    left = Math.max(0, left);
+    top = Math.max(0, top);
+    right = Math.min(vp.vw, right);
+    bottom = Math.min(vp.vh, bottom);
+    if (right - left < MIN_W) {
+        if (movesW)
+            left = right - MIN_W;
+        else
+            right = left + MIN_W;
+    }
+    if (bottom - top < MIN_H) {
+        if (movesN)
+            top = bottom - MIN_H;
+        else
+            bottom = top + MIN_H;
+    }
+    return clampGeom({ x: left, y: top, w: right - left, h: bottom - top }, vp);
+}

package/dist/lib/redact.d.ts

@@ -0,0 +1 @@
+export declare function redactSensitive(text: string): string;

package/dist/lib/redact.js

@@ -0,0 +1,34 @@
+const PATTERNS = [
+    { kind: "openai-key", re: /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g },
+    { kind: "anthropic-key", re: /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g },
+    { kind: "aws-access-key", re: /\b(?:AKIA|ASIA)[0-9A-Z]{16}\b/g },
+    { kind: "github-token", re: /\bgh[opsur]_[A-Za-z0-9]{36,}\b/g },
+    { kind: "github-pat", re: /\bgithub_pat_[A-Za-z0-9_]{40,}\b/g },
+    { kind: "google-api-key", re: /\bAIza[0-9A-Za-z_-]{35}\b/g },
+    { kind: "slack-token", re: /\bxox[bpsare]-[A-Za-z0-9-]{10,}\b/g },
+    {
+        kind: "stripe-key",
+        re: /\b(?:sk|pk|rk)_(?:live|test)_[A-Za-z0-9]{24,}\b/g,
+    },
+    {
+        kind: "jwt",
+        re: /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+    },
+    { kind: "bearer", re: /\bBearer\s+[A-Za-z0-9._-]{20,}/g },
+    {
+        kind: "env-assign",
+        re: /\b((?:[A-Z][A-Z0-9_]*)?(?:API[_-]?KEY|SECRET(?:[_-]?KEY)?|ACCESS[_-]?TOKEN|AUTH[_-]?TOKEN|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CLIENT[_-]?SECRET)[A-Z0-9_]*)\s*[:=]\s*(["']?)([^\s"';|&]+)\2/gi,
+    },
+];
+export function redactSensitive(text) {
+    let out = text;
+    for (const { kind, re } of PATTERNS) {
+        if (kind === "env-assign") {
+            out = out.replace(re, (_m, name, q, _val) => `${name}=${q}<REDACTED>${q}`);
+        }
+        else {
+            out = out.replace(re, `<REDACTED:${kind}>`);
+        }
+    }
+    return out;
+}

package/dist/lib/security.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Path-safety guards for AI tool calls.
+ *
+ * Goals:
+ *  - Block reads of files that almost always contain secrets (.env*, *.pem,
+ *    id_rsa*, .aws/credentials, .ssh/, .git/, kube/azure config, etc.).
+ *  - Block writes/exec into the same set, plus directories where automated
+ *    mutation is dangerous (system dirs, Windows system dirs).
+ *
+ * This is a *defense layer*, not a sandbox. The model may still be coaxed
+ * into doing something silly within allowed paths — the user-confirmation
+ * UI for write/exec is the real safety net. These checks ensure that
+ * read tools (which auto-approve) can never silently exfiltrate obvious
+ * secrets, and that a single bad approval can't blow up the system.
+ *
+ * Defense-in-depth notes:
+ *  - Comparison surface is lowercased *only for matching*. Original path is
+ *    preserved for basename pattern checks and error messages.
+ *  - Windows drive prefix (e.g. `C:`) is stripped from the comparison form so
+ *    Unix-style root prefix checks behave consistently on both platforms.
+ *  - Protected directories match exact-equal-or-descendant, not raw
+ *    substring-with-trailing-slash. Bare names (`/Users/me/.ssh`) and
+ *    case-variants (`/Users/me/.SSH/config` on macOS/Windows case-insensitive
+ *    filesystems) are caught.
+ *  - The caller is expected to additionally validate the *canonical* path
+ *    (post symlink resolution) via `getAiAdapter().native.canonicalize` + a second
+ *    `checkReadable` pass, since a symlink at an "innocent" path can point
+ *    into a protected directory.
+ */
+export type SafetyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function checkReadable(path: string): SafetyResult;
+export declare function checkWritable(path: string): SafetyResult;
+/**
+ * Lightweight heuristic for blocking obviously destructive shell commands
+ * even after the user has approved them. The approval UI shows the command
+ * verbatim, so the user is the primary gate; this just catches a couple of
+ * patterns that almost certainly indicate the model went off the rails.
+ */
+/**
+ * Two-phase safety check that also defends against symlink traversal: first
+ * checks the literal path, then (if it exists) canonicalizes it via the
+ * native FS and re-checks the resolved path. A symlink at `./innocent.txt`
+ * pointing into `~/.ssh/id_rsa` is caught on the second pass.
+ *
+ * Returns the canonical path on success so callers can use it for the actual
+ * read — avoids TOCTOU between the safety check and the read.
+ */
+export declare function checkReadableCanonical(path: string, canonicalize: (p: string) => Promise<string>): Promise<{
+    ok: true;
+    canonical: string;
+} | {
+    ok: false;
+    reason: string;
+}>;
+/**
+ * Same pattern as {@link checkReadableCanonical} but for writes. The canonical
+ * path is only available if the file already exists — for new-file creates
+ * we additionally canonicalize the parent directory.
+ */
+export declare function checkWritableCanonical(path: string, canonicalize: (p: string) => Promise<string>): Promise<{
+    ok: true;
+    canonical: string;
+} | {
+    ok: false;
+    reason: string;
+}>;
+export declare function checkShellCommand(cmd: string): SafetyResult;