@alisio/core 0.1.0-alpha.10

package/dist/tools/webfetch.d.ts

@@ -0,0 +1,26 @@
+export type WebfetchFormat = "markdown" | "text" | "html";
+export declare const MAX_RESPONSE_BYTES: number;
+export declare const MAX_TIMEOUT_SECONDS = 120;
+export declare const DEFAULT_TIMEOUT_SECONDS = 30;
+/** Characters embedded directly in the tool result before the rest is only available via `read_file`. */
+export declare const MAX_EMBEDDED_CHARS = 20000;
+export declare function isTextualContentType(contentType: string): boolean;
+export interface WebfetchResult {
+    url: string;
+    status: number;
+    contentType: string;
+    format: WebfetchFormat;
+    content: string;
+    truncated: boolean;
+    /** Present only when `truncated`: a workspace-relative path with the full converted text, readable via `read_file`. */
+    fullTextPath?: string;
+    bytes: number;
+}
+/**
+ * Fetches `url` and returns it as text/markdown/html. Redirects are followed by `fetch` itself
+ * (capped at the runtime's own default, ~20 hops). Non-textual responses (images, binaries) are
+ * refused with a clear error rather than returned as garbage. When the converted text is larger
+ * than `MAX_EMBEDDED_CHARS`, the full text is written to a workspace-scoped cache file
+ * (`.alisio/cache/webfetch/<hash>.<ext>`) so a follow-up `read_file` is never lossy.
+ */
+export declare function webfetch(workspace: string, url: string, format: WebfetchFormat | undefined, timeoutSeconds: number | undefined, signal: AbortSignal): Promise<WebfetchResult>;

package/dist/tools/webfetch.js

@@ -0,0 +1,119 @@
+/**
+ * `webfetch`: read a URL as text/markdown/html. Node-native `fetch` only (no extra HTTP client
+ * dependency); HTML conversion uses `turndown` (a small, widely used converter whose only runtime
+ * dependency is `@mixmark-io/domino`, a pure-JS DOM implementation — no jsdom, no headless
+ * browser). This mirrors the vetted approach opencode itself uses for the same job.
+ */
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import domino from "@mixmark-io/domino";
+import TurndownService from "turndown";
+import { safePath } from "../runtime/paths.js";
+export const MAX_RESPONSE_BYTES = 5 * 1024 * 1024; // 5 MiB, matching the size cap other well-known fetch tools use.
+export const MAX_TIMEOUT_SECONDS = 120;
+export const DEFAULT_TIMEOUT_SECONDS = 30;
+/** Characters embedded directly in the tool result before the rest is only available via `read_file`. */
+export const MAX_EMBEDDED_CHARS = 20_000;
+const TEXTUAL_TYPES = new Set([
+    "application/json",
+    "application/xml",
+    "application/xhtml+xml",
+    "application/javascript",
+    "application/atom+xml",
+    "application/rss+xml",
+]);
+export function isTextualContentType(contentType) {
+    const type = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+    return type.startsWith("text/") || TEXTUAL_TYPES.has(type);
+}
+function htmlToMarkdown(html) {
+    const turndown = new TurndownService({
+        headingStyle: "atx",
+        bulletListMarker: "-",
+        codeBlockStyle: "fenced",
+    });
+    turndown.remove(["script", "style", "noscript", "meta", "link"]);
+    return turndown.turndown(html).trim();
+}
+function htmlToText(html) {
+    const document = domino.createDocument(html);
+    for (const el of [...document.querySelectorAll("script, style, noscript")])
+        el.remove();
+    const text = document.body?.textContent ?? document.documentElement?.textContent ?? "";
+    return text
+        .split("\n")
+        .map((l) => l.trim())
+        .filter(Boolean)
+        .join("\n");
+}
+/**
+ * Fetches `url` and returns it as text/markdown/html. Redirects are followed by `fetch` itself
+ * (capped at the runtime's own default, ~20 hops). Non-textual responses (images, binaries) are
+ * refused with a clear error rather than returned as garbage. When the converted text is larger
+ * than `MAX_EMBEDDED_CHARS`, the full text is written to a workspace-scoped cache file
+ * (`.alisio/cache/webfetch/<hash>.<ext>`) so a follow-up `read_file` is never lossy.
+ */
+export async function webfetch(workspace, url, format = "markdown", timeoutSeconds = DEFAULT_TIMEOUT_SECONDS, signal) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`webfetch: not a valid URL: ${url}`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+        throw new Error(`webfetch only supports http(s) URLs, got: ${parsed.protocol}`);
+    const seconds = Math.min(MAX_TIMEOUT_SECONDS, Math.max(1, timeoutSeconds));
+    const combined = AbortSignal.any([signal, AbortSignal.timeout(seconds * 1000)]);
+    const res = await fetch(parsed, {
+        signal: combined,
+        redirect: "follow",
+        headers: {
+            // A default fetch UA is blocked by some sites; a browser-like UA matches common practice
+            // for this exact kind of tool (opencode does the same) without impersonating a real user.
+            "User-Agent": "Mozilla/5.0 (compatible; AlisioAgent/1.0; +https://github.com/GustavoGutierrez/alisio)",
+            Accept: format === "html" ? "text/html,*/*;q=0.8" : "text/html,text/plain,*/*;q=0.8",
+        },
+    });
+    const contentType = res.headers.get("content-type") ?? "";
+    const declaredLength = Number(res.headers.get("content-length") ?? "0");
+    if (declaredLength > MAX_RESPONSE_BYTES)
+        throw new Error(`webfetch: response too large (${declaredLength} bytes, limit ${MAX_RESPONSE_BYTES})`);
+    if (!isTextualContentType(contentType))
+        throw new Error(`webfetch only supports textual content (text/*, JSON, XML); got content-type ` +
+            `"${contentType || "unknown"}". Binary and image responses are refused.`);
+    const buffer = await res.arrayBuffer();
+    if (buffer.byteLength > MAX_RESPONSE_BYTES)
+        throw new Error(`webfetch: response too large (${buffer.byteLength} bytes, limit ${MAX_RESPONSE_BYTES})`);
+    const raw = Buffer.from(buffer).toString("utf8");
+    const isHtml = contentType.includes("html");
+    const converted = format === "html"
+        ? raw
+        : isHtml
+            ? format === "text"
+                ? htmlToText(raw)
+                : htmlToMarkdown(raw)
+            : raw;
+    const truncated = converted.length > MAX_EMBEDDED_CHARS;
+    let fullTextPath;
+    if (truncated) {
+        const ext = format === "html" ? "html" : format === "text" ? "txt" : "md";
+        const hash = createHash("sha256").update(`${url}\n${format}`).digest("hex").slice(0, 24);
+        const relative = join(".alisio", "cache", "webfetch", `${hash}.${ext}`);
+        const path = await safePath(workspace, relative);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, converted, "utf8");
+        fullTextPath = relative;
+    }
+    return {
+        url: parsed.toString(),
+        status: res.status,
+        contentType,
+        format,
+        content: converted.slice(0, MAX_EMBEDDED_CHARS),
+        truncated,
+        ...(fullTextPath ? { fullTextPath } : {}),
+        bytes: buffer.byteLength,
+    };
+}

package/dist/trust.d.ts

@@ -0,0 +1,34 @@
+export interface TrustEntry {
+    trusted: boolean;
+    /** sha256 of `.alisio/config.json`'s content, or null when that file does not exist. */
+    configHash: string | null;
+    updatedAt: number;
+}
+export interface TrustListing extends TrustEntry {
+    workspace: string;
+}
+/** Resolving a workspace's trust, without ever prompting. */
+export interface TrustResolution {
+    /** Whether the workspace's project resources should currently load. */
+    trusted: boolean;
+    /** Whether there is anything here needing a trust decision in the first place. */
+    hasProjectResources: boolean;
+    /** True when the caller should ask (no stored decision, or the config changed since). */
+    needsPrompt: boolean;
+    configHash: string | null;
+}
+export declare function trustStorePath(): string;
+export declare function hasProjectResources(workspace: string): Promise<boolean>;
+export declare function hashProjectConfig(workspace: string): Promise<string | null>;
+/** The raw stored decision for a workspace, or undefined when none exists yet. */
+export declare function getTrust(workspace: string): Promise<TrustEntry | undefined>;
+export declare function setTrust(workspace: string, trusted: boolean, configHash: string | null): Promise<void>;
+/** Returns whether an entry actually existed to remove. */
+export declare function revokeTrust(workspace: string): Promise<boolean>;
+export declare function listTrust(): Promise<TrustListing[]>;
+/**
+ * Read-only resolution: never prompts. `needsPrompt` tells an interactive caller it must ask
+ * (nothing stored yet, or `.alisio/config.json` changed since the last decision — a changed file
+ * is never trusted silently). A headless caller should treat `needsPrompt` the same as untrusted.
+ */
+export declare function resolveTrust(workspace: string): Promise<TrustResolution>;

package/dist/trust.js

@@ -0,0 +1,113 @@
+/**
+ * One-time, per-directory project trust, replacing `--trust-project` for the common interactive
+ * case. Trusting a workspace lets Alisio load `.alisio/config.json` (which can redirect the
+ * provider endpoint/API key), `.alisio/plugins` (executable code), and project agents/skills/
+ * prompts — exactly the same things `--trust-project`/`--config` already unlock for one run. This
+ * module only decides and persists the yes/no; it never itself prompts (that is a CLI/TUI concern,
+ * since only an interactive caller has someone to ask) and it never mutates policy.
+ *
+ * Never used for a `--trust-project`/`--config` invocation: that flag is already explicit, one-run
+ * trust and must not be persisted as though it were an interactive grant.
+ */
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { stateHome } from "./config.js";
+export function trustStorePath() {
+    return join(stateHome(), "trust.json");
+}
+/** Project-level resources that today require `--trust-project`/`--config` to load. */
+const PROJECT_RESOURCE_RELATIVE_PATHS = [
+    ".alisio/config.json",
+    ".alisio/plugins",
+    ".alisio/agents",
+    ".agents/agents",
+    ".alisio/skills",
+    ".alisio/prompts",
+];
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function hasProjectResources(workspace) {
+    for (const relative of PROJECT_RESOURCE_RELATIVE_PATHS)
+        if (await pathExists(join(workspace, relative)))
+            return true;
+    return false;
+}
+export async function hashProjectConfig(workspace) {
+    try {
+        const content = await readFile(join(workspace, ".alisio", "config.json"), "utf8");
+        return createHash("sha256").update(content).digest("hex");
+    }
+    catch {
+        return null;
+    }
+}
+async function readStore() {
+    try {
+        const raw = JSON.parse(await readFile(trustStorePath(), "utf8"));
+        if (raw && typeof raw === "object" && raw.entries && typeof raw.entries === "object")
+            return { version: 1, entries: raw.entries };
+    }
+    catch {
+        /* Missing or corrupt: start fresh rather than fail the whole CLI over a trust cache. */
+    }
+    return { version: 1, entries: {} };
+}
+async function writeStore(store) {
+    const path = trustStorePath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${crypto.randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+/** The raw stored decision for a workspace, or undefined when none exists yet. */
+export async function getTrust(workspace) {
+    return (await readStore()).entries[workspace];
+}
+export async function setTrust(workspace, trusted, configHash) {
+    const store = await readStore();
+    store.entries[workspace] = { trusted, configHash, updatedAt: Date.now() };
+    await writeStore(store);
+}
+/** Returns whether an entry actually existed to remove. */
+export async function revokeTrust(workspace) {
+    const store = await readStore();
+    if (!(workspace in store.entries))
+        return false;
+    delete store.entries[workspace];
+    await writeStore(store);
+    return true;
+}
+export async function listTrust() {
+    const store = await readStore();
+    return Object.entries(store.entries)
+        .map(([workspace, entry]) => ({ workspace, ...entry }))
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+}
+/**
+ * Read-only resolution: never prompts. `needsPrompt` tells an interactive caller it must ask
+ * (nothing stored yet, or `.alisio/config.json` changed since the last decision — a changed file
+ * is never trusted silently). A headless caller should treat `needsPrompt` the same as untrusted.
+ */
+export async function resolveTrust(workspace) {
+    const hasResources = await hasProjectResources(workspace);
+    const configHash = await hashProjectConfig(workspace);
+    if (!hasResources)
+        return { trusted: false, hasProjectResources: false, needsPrompt: false, configHash };
+    const stored = await getTrust(workspace);
+    if (!stored || stored.configHash !== configHash)
+        return { trusted: false, hasProjectResources: true, needsPrompt: true, configHash };
+    return { trusted: stored.trusted, hasProjectResources: true, needsPrompt: false, configHash };
+}

package/dist/version.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads the @alisio/core package version at runtime so the MCP client metadata stays in sync
+ * with the published package. Resolves the manifest relative to the module (`src/version.ts` →
+ * `../package.json` in the source tree; `dist/version.js` → `../package.json` when installed).
+ * Standalone binaries inject ALISIO_PACKAGE_VERSION at build time (scripts/binary-build.ts).
+ */
+export declare function loadVersion(fromHere: string): string;

package/dist/version.js

@@ -0,0 +1,26 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Fallback used when neither the build-time injection nor the package manifest is readable.
+ * A development marker, never a publish literal: it cannot silently desync from the package.
+ */
+const FALLBACK = "dev";
+/**
+ * Reads the @alisio/core package version at runtime so the MCP client metadata stays in sync
+ * with the published package. Resolves the manifest relative to the module (`src/version.ts` →
+ * `../package.json` in the source tree; `dist/version.js` → `../package.json` when installed).
+ * Standalone binaries inject ALISIO_PACKAGE_VERSION at build time (scripts/binary-build.ts).
+ */
+export function loadVersion(fromHere) {
+    if (process.env.ALISIO_PACKAGE_VERSION)
+        return process.env.ALISIO_PACKAGE_VERSION;
+    try {
+        const manifest = join(dirname(fileURLToPath(fromHere)), "..", "package.json");
+        const parsed = JSON.parse(readFileSync(manifest, "utf8"));
+        return typeof parsed.version === "string" && parsed.version ? parsed.version : FALLBACK;
+    }
+    catch {
+        return FALLBACK;
+    }
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@alisio/core",
+  "version": "0.1.0-alpha.10",
+  "description": "Embeddable provider-agnostic Alisio agent core: tool loop, context compaction, local tools, MCP, plugin host and SQLite session store. Runs on Node >=22.16 and Bun.",
+  "author": "Gustavo Gutiérrez",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GustavoGutierrez/alisio.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://gustavogutierrez.github.io/alisio/",
+  "bugs": {
+    "url": "https://github.com/GustavoGutierrez/alisio/issues"
+  },
+  "keywords": [
+    "ai",
+    "coding-agent",
+    "llm",
+    "agent-harness",
+    "openai-compatible",
+    "plugins",
+    "mcp",
+    "agent"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.16"
+  },
+  "dependencies": {
+    "@alisio/sdk": "0.1.0-alpha.6",
+    "@mixmark-io/domino": "2.2.0",
+    "@modelcontextprotocol/client": "2.1.0",
+    "ajv": "8.20.0",
+    "turndown": "7.2.4",
+    "yaml": "2.9.1",
+    "zod": "4.6.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.com/"
+  },
+  "devDependencies": {
+    "@types/turndown": "5.0.6"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json"
+  }
+}