@causyne/agent 1.10.12 → 1.10.17

package/src/provisioning/capabilityProvisioner.d.ts

@@ -0,0 +1,10 @@
+export interface CapabilityVerdict {
+  ok: boolean;
+  group: string;
+  reason?: string;
+  requiresConsent?: boolean;
+}
+
+export function ensureCapability(group: string): Promise<CapabilityVerdict>;
+export function loadCapabilityPackage(packageName: string): Promise<unknown>;
+export function capabilityDirectory(): string;

package/src/provisioning/capabilityProvisioner.js

@@ -15,6 +15,10 @@ const CAPABILITY_DIR = path.join(causyneHome(), 'capabilities');
 // ("let it see the screen"), not once per npm package. Names stay in value
 // position — see the D-5 note above.
 const GROUP_PACKAGES = {
+  browser: [
+    ['camoufox-js', '0.11.5'],
+    ['playwright-core', '1.58.0']
+  ],
   vision: [
     ['puppeteer-core', '25.8.0'],
     ['screenshot-desktop', '1.15.6']
@@ -40,6 +44,7 @@ const GROUP_PACKAGES = {
 
 // than listing package names.
 export const GROUP_DESCRIPTIONS = {
+  browser: 'use an existing Camoufox installation for rendered navigation, extraction, and workspace-scoped downloads; Causyne never downloads the browser binary automatically',
   vision: 'drive a browser and capture the screen, so the agent can look at what it built',
   ocr: 'read text out of images and screenshots',
   system: 'list running processes and read system load',

package/src/provisioning/capabilityTools.js

@@ -11,7 +11,8 @@
 import { isGroupDeclined } from './capabilityConsent.js';
 
 export const TOOLS_BY_GROUP = {
-  vision: ['browser_act', 'screenshot', 'vision_inspect_ui', 'game_canvas_audit', 'game_web_runtime_inspector'],
+  browser: ['browser_act'],
+  vision: ['screenshot', 'vision_inspect_ui', 'game_canvas_audit', 'game_web_runtime_inspector'],
   ocr: [],
   system: ['process_list'],
   desktop: ['clipboard', 'desktop_open'],

package/src/sandbox.js

@@ -1,5 +1,6 @@
 import path from 'path';
 import os from 'os';
+import { isIP } from 'node:net';
 import { loadConfig } from './config.js';
 import { isDevEmulator } from './devMode.js';
 
@@ -183,6 +184,10 @@ export class Sandbox {
     const devMode = isDevEmulator(this.config);
     this.grantAllAccess = devMode ? true : (this.config.grantAllAccess || false);
     this.allowedTools = devMode ? ['*'] : (this.config.allowedTools || ['*']);
+    this.deniedTools = new Set(
+      (devMode ? [] : (this.config.deniedTools || []))
+        .map((name) => String(name).replace(/\./g, '_'))
+    );
   }
 
   
@@ -214,6 +219,9 @@ export class Sandbox {
 
   validate(toolName, args) {
     // 1. Tool availability check
+    if (this.deniedTools.has(String(toolName).replace(/\./g, '_'))) {
+      return { allowed: false, reason: `Tool ${toolName} is denied by local policy`, risk: 'forbidden' };
+    }
     if (!this.allowedTools.includes('*') && !this.allowedTools.includes(toolName)) {
       return { allowed: false, reason: `Tool ${toolName} not allowed on current tier`, risk: 'forbidden' };
     }
@@ -269,6 +277,27 @@ export class Sandbox {
       }
     }
 
+    if (toolName === 'browser_act') {
+      const actions = Array.isArray(args.actions) ? args.actions : [];
+      let hasDownload = false;
+      for (const action of actions) {
+        if (action && action.url && this.isInternalUrl(action.url)) {
+          return { allowed: false, reason: 'Cannot navigate the agent browser to an internal or invalid URL', risk: 'forbidden' };
+        }
+        if (action && ['download', 'screenshot'].includes(action.type)) {
+          if (!action.outputFile || !this.isPathAllowed(path.resolve(this.workspacePaths[0], action.outputFile))) {
+            return { allowed: false, reason: 'Browser downloads must stay inside the selected workspace', risk: 'forbidden' };
+          }
+          hasDownload = true;
+        }
+      }
+      if (hasDownload) return { allowed: true, risk: 'extreme', reason: 'Writes browser content to the selected workspace' };
+      if (actions.some(action => ['click', 'clickIndex', 'type', 'typeIndex', 'selectOption', 'keyPress'].includes(action?.type))) {
+        return { allowed: true, risk: 'dangerous', reason: 'Interacts with a website through the dedicated agent browser' };
+      }
+      return { allowed: true, risk: 'safe' };
+    }
+
     if (toolName === 'game_asset_fetch' && args.action === 'download_asset') {
       if (!args.url || this.isInternalUrl(args.url)) {
         return { allowed: false, reason: 'Cannot download from an internal or invalid URL', risk: 'forbidden' };
@@ -288,6 +317,20 @@ export class Sandbox {
       }
       return { allowed: true, risk: 'moderate' };
     }
+
+    // Plugins are code extensions. Creation and enablement change the future
+    // executable surface, and an enabled plugin call crosses from Causyne's
+    // reviewed code into user/third-party code. Keep both explicit and
+    // session-revocable even though the plugin process also runs under Node's
+    // filesystem/network/child-process permission model.
+    if (toolName === 'plugin_manager') {
+      return ['create', 'enable'].includes(args.action)
+        ? { allowed: true, risk: 'extreme', reason: 'Creates or trusts executable plugin code' }
+        : { allowed: true, risk: 'safe' };
+    }
+    if (toolName.startsWith('plugin__')) {
+      return { allowed: true, risk: 'extreme', reason: 'Executes an enabled local plugin' };
+    }
     
     // Tools that overwrite or delete are inherently dangerous.
     // These comparisons used the dotted schema names (`fs.delete`, `proc.term`,
@@ -369,11 +412,19 @@ export class Sandbox {
   isInternalUrl(urlString) {
     try {
       const url = new URL(urlString);
-      const host = url.hostname;
+      if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return true;
+      const host = url.hostname.toLowerCase().replace(/^\[|\]$/g, '').replace(/\.$/, '');
+      if (host === 'localhost' || host.endsWith('.localhost') || host.endsWith('.local') || host.endsWith('.internal')) return true;
       
       // Block localhost, private IPs, cloud metadata
-      const blockedRegex = /^(localhost|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|192\.168\.\d+\.\d+|169\.254\.\d+\.\d+|0\.0\.0\.0)$/;
+      const blockedRegex = /^(localhost|0\.\d+\.\d+\.\d+|127\.\d+\.\d+\.\d+|10\.\d+\.\d+\.\d+|100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.\d+\.\d+|172\.(1[6-9]|2\d|3[01])\.\d+\.\d+|169\.254\.\d+\.\d+|192\.168\.\d+\.\d+|192\.0\.(0|2)\.\d+|192\.88\.99\.\d+|198\.(18|19)\.\d+\.\d+|198\.51\.100\.\d+|203\.0\.113\.\d+|(22[4-9]|23\d|24\d|25[0-5])\.\d+\.\d+\.\d+)$/;
       if (blockedRegex.test(host)) return true;
+      if (host === 'metadata.google.internal') return true;
+      if (isIP(host) === 6) {
+        const normalized = host.split('%')[0];
+        if (normalized === '::' || normalized === '::1' || /^(fc|fd|fe8|fe9|fea|feb|fec|fed|fee|fef|ff|2001:db8:|64:ff9b:)/.test(normalized)) return true;
+        if (normalized.startsWith('::ffff:')) return true;
+      }
       
       return false;
     } catch(e) {

package/src/sessionJournal.js

@@ -0,0 +1,471 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { causyneHome } from './utils/paths.js';
+export const SESSION_DIR = path.join(causyneHome(), 'sessions');
+const LEGACY_HISTORY = path.join(causyneHome(), 'memory', 'chat_history.json');
+const POINTER_FILE = path.join(SESSION_DIR, 'active.json');
+export const RESUME_WINDOW_MS = 12 * 60 * 60 * 1000;
+export const MAX_SESSIONS = 50;
+const MAX_TRANSCRIPT_BYTES = 64 * 1024 * 1024;
+const MAX_EVENT_BYTES = 8 * 1024 * 1024;
+function ensureDir() {
+    if (!fs.existsSync(SESSION_DIR))
+        fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
+}
+function safeSessionId(id) {
+    return String(id ?? '').replace(/[^a-zA-Z0-9_-]/g, '');
+}
+function workspaceKey(workspace) {
+    return crypto.createHash('sha256').update(String(workspace ?? '')).digest('hex').slice(0, 12);
+}
+export function sessionTranscriptFile(id) {
+    return path.join(SESSION_DIR, `${safeSessionId(id)}.jsonl`);
+}
+function legacySessionFile(id) {
+    return path.join(SESSION_DIR, `${safeSessionId(id)}.json`);
+}
+function isObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function validMessage(value) {
+    return isObject(value) && typeof value.role === 'string' && value.role.length > 0;
+}
+function validMessages(value) {
+    return Array.isArray(value) && value.every(validMessage);
+}
+function parseEvent(value) {
+    if (!isObject(value) || value.version !== 1 || typeof value.type !== 'string' || typeof value.at !== 'number')
+        return null;
+    if (value.type === 'session.created') {
+        const session = value.session;
+        if (!isObject(session)
+            || typeof session.id !== 'string'
+            || typeof session.workspace !== 'string'
+            || typeof session.workspaceKey !== 'string'
+            || typeof session.title !== 'string'
+            || typeof session.createdAt !== 'number')
+            return null;
+        return value;
+    }
+    if (value.type === 'messages.appended') {
+        if (!validMessages(value.messages))
+            return null;
+        if (value.title !== undefined && typeof value.title !== 'string')
+            return null;
+        return value;
+    }
+    if (value.type === 'messages.replaced') {
+        if (!validMessages(value.messages))
+            return null;
+        if (value.title !== undefined && typeof value.title !== 'string')
+            return null;
+        return value;
+    }
+    if (value.type === 'messages.windowed') {
+        if (!Number.isInteger(value.dropPrefix) || Number(value.dropPrefix) < 0 || !validMessages(value.messages))
+            return null;
+        if (value.title !== undefined && typeof value.title !== 'string')
+            return null;
+        return value;
+    }
+    return null;
+}
+function projectTranscript(text) {
+    const trailingNewline = text.endsWith('\n');
+    const lines = text.split('\n');
+    if (lines.at(-1) === '')
+        lines.pop();
+    let session = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === undefined || line.trim() === '')
+            continue;
+        if (Buffer.byteLength(line, 'utf8') > MAX_EVENT_BYTES)
+            return null;
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            // O_APPEND can still be interrupted between bytes. Retain complete events
+            // before a torn final line; never guess around corruption in the middle.
+            if (index === lines.length - 1 && !trailingNewline)
+                break;
+            return null;
+        }
+        const event = parseEvent(raw);
+        if (!event)
+            return null;
+        if (event.type === 'session.created') {
+            if (session)
+                return null;
+            session = { ...event.session, updatedAt: event.at, messages: [] };
+            continue;
+        }
+        if (!session)
+            return null;
+        if (event.type === 'messages.appended')
+            session.messages.push(...event.messages);
+        else if (event.type === 'messages.replaced')
+            session.messages = event.messages.slice();
+        else {
+            if (event.dropPrefix > session.messages.length)
+                return null;
+            session.messages = session.messages.slice(event.dropPrefix).concat(event.messages);
+        }
+        if (event.title !== undefined)
+            session.title = event.title;
+        session.updatedAt = event.at;
+    }
+    return session;
+}
+function readTranscriptFile(file) {
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile() || stat.size > MAX_TRANSCRIPT_BYTES)
+            return null;
+        return projectTranscript(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function appendEvent(file, event) {
+    try {
+        ensureDir();
+        const line = `${JSON.stringify(event)}\n`;
+        if (Buffer.byteLength(line, 'utf8') > MAX_EVENT_BYTES)
+            return false;
+        fs.appendFileSync(file, line, { encoding: 'utf8', mode: 0o600, flag: 'a' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function writeNewTranscript(session) {
+    try {
+        ensureDir();
+        const created = {
+            version: 1,
+            type: 'session.created',
+            at: session.createdAt,
+            session: {
+                id: session.id,
+                workspace: session.workspace,
+                workspaceKey: session.workspaceKey,
+                title: session.title,
+                createdAt: session.createdAt
+            }
+        };
+        let text = `${JSON.stringify(created)}\n`;
+        if (session.messages.length > 0) {
+            const restored = {
+                version: 1,
+                type: 'messages.replaced',
+                at: session.updatedAt,
+                messages: session.messages,
+                title: session.title
+            };
+            text += `${JSON.stringify(restored)}\n`;
+        }
+        fs.writeFileSync(sessionTranscriptFile(session.id), text, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function migrateLegacySession(id) {
+    const file = legacySessionFile(id);
+    try {
+        if (!fs.existsSync(file))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!isObject(parsed)
+            || parsed.id !== id
+            || typeof parsed.workspace !== 'string'
+            || typeof parsed.title !== 'string'
+            || typeof parsed.createdAt !== 'number'
+            || typeof parsed.updatedAt !== 'number'
+            || !validMessages(parsed.messages))
+            return null;
+        const session = {
+            id,
+            workspace: parsed.workspace,
+            workspaceKey: typeof parsed.workspaceKey === 'string' ? parsed.workspaceKey : workspaceKey(parsed.workspace),
+            title: parsed.title,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt,
+            messages: parsed.messages
+        };
+        if (!writeNewTranscript(session))
+            return null;
+        fs.renameSync(file, `${file}.migrated`);
+        return session;
+    }
+    catch {
+        return null;
+    }
+}
+function readSession(id) {
+    const safe = safeSessionId(id);
+    if (!safe)
+        return null;
+    const journal = sessionTranscriptFile(safe);
+    if (fs.existsSync(journal))
+        return readTranscriptFile(journal);
+    return migrateLegacySession(safe);
+}
+export function titleFrom(text) {
+    const clean = String(text ?? '').replace(/\s+/g, ' ').trim();
+    if (!clean)
+        return 'Untitled';
+    return clean.length > 60 ? `${clean.slice(0, 57)}…` : clean;
+}
+export function listSessions() {
+    try {
+        ensureDir();
+        const ids = new Set();
+        for (const name of fs.readdirSync(SESSION_DIR)) {
+            const match = name.match(/^(s_[a-zA-Z0-9_-]+)\.(?:jsonl|json)$/);
+            if (match?.[1])
+                ids.add(match[1]);
+        }
+        const rows = [];
+        for (const id of ids) {
+            const session = readSession(id);
+            if (!session)
+                continue;
+            const { messages, ...metadata } = session;
+            rows.push({ ...metadata, messageCount: messages.length });
+        }
+        return rows.sort((left, right) => right.updatedAt - left.updatedAt);
+    }
+    catch {
+        return [];
+    }
+}
+export function pruneSessions(max = MAX_SESSIONS) {
+    let removed = 0;
+    for (const row of listSessions().slice(max)) {
+        let removedSession = false;
+        for (const file of [sessionTranscriptFile(row.id), legacySessionFile(row.id), `${legacySessionFile(row.id)}.migrated`]) {
+            try {
+                fs.unlinkSync(file);
+                removedSession = true;
+            }
+            catch { /* absent files need no action */ }
+        }
+        if (removedSession)
+            removed += 1;
+    }
+    return removed;
+}
+export function createSession(workspace, title = 'Untitled') {
+    const now = Date.now();
+    const workspaceText = String(workspace ?? '');
+    const session = {
+        id: `s_${now.toString(36)}_${crypto.randomBytes(3).toString('hex')}`,
+        workspace: workspaceText,
+        workspaceKey: workspaceKey(workspaceText),
+        title,
+        createdAt: now,
+        updatedAt: now,
+        messages: []
+    };
+    // Persistence is best-effort. An unavailable state directory must not stop a
+    // user from starting an otherwise usable foreground session.
+    writeNewTranscript(session);
+    setActiveSession(session.id);
+    pruneSessions();
+    return session;
+}
+export function getActiveSessionId() {
+    try {
+        if (!fs.existsSync(POINTER_FILE))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(POINTER_FILE, 'utf8'));
+        return isObject(parsed) && typeof parsed.id === 'string' && parsed.id ? parsed.id : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function setActiveSession(id) {
+    try {
+        ensureDir();
+        const safe = safeSessionId(id);
+        fs.writeFileSync(POINTER_FILE, `${JSON.stringify({ id: safe || null, at: Date.now() }, null, 2)}\n`, { mode: 0o600 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function resolveSession(workspace) {
+    const workspaceText = String(workspace ?? '');
+    ensureDir();
+    migrateLegacyHistory(workspaceText);
+    const key = workspaceKey(workspaceText);
+    const now = Date.now();
+    const candidate = listSessions()
+        .filter((row) => row.workspace && row.workspaceKey === key)
+        .find((row) => now - row.updatedAt < RESUME_WINDOW_MS);
+    if (candidate) {
+        const session = readSession(candidate.id);
+        if (session) {
+            setActiveSession(session.id);
+            return session;
+        }
+    }
+    return createSession(workspaceText);
+}
+export function switchSession(id) {
+    const session = readSession(id);
+    if (!session)
+        return null;
+    setActiveSession(session.id);
+    return session;
+}
+function messageEqual(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function suffixPrefixOverlap(previous, next) {
+    const ceiling = Math.min(previous.length, next.length);
+    for (let size = ceiling; size > 0; size -= 1) {
+        const offset = previous.length - size;
+        let matches = true;
+        for (let index = 0; index < size; index += 1) {
+            const left = previous[offset + index];
+            const right = next[index];
+            if (left === undefined || right === undefined || !messageEqual(left, right)) {
+                matches = false;
+                break;
+            }
+        }
+        if (matches)
+            return size;
+    }
+    return 0;
+}
+export function saveSessionMessages(id, messages) {
+    const session = readSession(id);
+    if (!session || !validMessages(messages))
+        return false;
+    const nextMessages = messages.slice();
+    const firstUser = nextMessages.find((message) => message.role === 'user' && typeof message.content === 'string');
+    const nextTitle = (!session.title || session.title === 'Untitled') && firstUser
+        ? titleFrom(firstUser.content)
+        : session.title;
+    const prefix = session.messages.length <= nextMessages.length
+        && session.messages.every((message, index) => {
+            const next = nextMessages[index];
+            return next !== undefined && messageEqual(message, next);
+        });
+    const changedTitle = nextTitle !== session.title;
+    if (prefix && session.messages.length === nextMessages.length && !changedTitle)
+        return true;
+    let event;
+    if (prefix) {
+        event = {
+            version: 1,
+            type: 'messages.appended',
+            at: Date.now(),
+            messages: nextMessages.slice(session.messages.length),
+            ...(changedTitle ? { title: nextTitle } : {})
+        };
+    }
+    else {
+        const overlap = suffixPrefixOverlap(session.messages, nextMessages);
+        event = overlap > 0 || nextMessages.length === 0
+            ? {
+                version: 1,
+                type: 'messages.windowed',
+                at: Date.now(),
+                dropPrefix: session.messages.length - overlap,
+                messages: nextMessages.slice(overlap),
+                ...(changedTitle ? { title: nextTitle } : {})
+            }
+            : {
+                version: 1,
+                type: 'messages.replaced',
+                at: Date.now(),
+                messages: nextMessages,
+                ...(changedTitle ? { title: nextTitle } : {})
+            };
+    }
+    return appendEvent(sessionTranscriptFile(session.id), event);
+}
+export function restoreSessionFromSnapshot(file, snapshot) {
+    try {
+        const resolved = path.resolve(file);
+        const root = path.resolve(SESSION_DIR);
+        if (path.dirname(resolved) !== root || path.extname(resolved) !== '.jsonl')
+            return false;
+        const restored = projectTranscript(snapshot.toString('utf8'));
+        if (!restored || sessionTranscriptFile(restored.id) !== resolved)
+            return false;
+        if (!fs.existsSync(resolved)) {
+            fs.writeFileSync(resolved, snapshot, { mode: 0o600, flag: 'wx' });
+            return true;
+        }
+        return appendEvent(resolved, {
+            version: 1,
+            type: 'messages.replaced',
+            at: Date.now(),
+            messages: restored.messages,
+            title: restored.title
+        });
+    }
+    catch {
+        return false;
+    }
+}
+export function deleteSession(id) {
+    const safe = safeSessionId(id);
+    if (!safe)
+        return false;
+    let removed = false;
+    for (const file of [sessionTranscriptFile(safe), legacySessionFile(safe), `${legacySessionFile(safe)}.migrated`]) {
+        try {
+            fs.unlinkSync(file);
+            removed = true;
+        }
+        catch { /* absent files need no action */ }
+    }
+    if (removed && getActiveSessionId() === safe)
+        setActiveSession(null);
+    return removed;
+}
+export function migrateLegacyHistory(workspace) {
+    try {
+        if (!fs.existsSync(LEGACY_HISTORY))
+            return null;
+        const parsed = JSON.parse(fs.readFileSync(LEGACY_HISTORY, 'utf8'));
+        if (!validMessages(parsed) || parsed.length === 0) {
+            fs.renameSync(LEGACY_HISTORY, `${LEGACY_HISTORY}.migrated`);
+            return null;
+        }
+        const firstUser = parsed.find((message) => message.role === 'user' && typeof message.content === 'string');
+        const session = createSession(workspace, titleFrom(firstUser?.content ?? 'Imported conversation'));
+        const imported = {
+            ...session,
+            workspace: '',
+            workspaceKey: '',
+            title: session.title === 'Untitled' ? 'Imported conversation' : `${session.title} (imported)`,
+            createdAt: fs.statSync(LEGACY_HISTORY).mtimeMs,
+            updatedAt: Date.now(),
+            messages: parsed.filter((message) => message.role !== 'system')
+        };
+        fs.unlinkSync(sessionTranscriptFile(session.id));
+        if (!writeNewTranscript(imported))
+            return null;
+        fs.renameSync(LEGACY_HISTORY, `${LEGACY_HISTORY}.migrated`);
+        return imported;
+    }
+    catch {
+        return null;
+    }
+}