qlogicagent 2.13.5 → 2.13.6

package/dist/runtime/sandbox/skill-sandbox.test.js

@@ -1,172 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { createSkillSandbox } from "./skill-sandbox.js";
-import { buildWindowsSandboxLaunchMetadata, createWindowsProcessTreeLauncher, } from "./windows-skill-sandbox.js";
-describe("OS-native launcher L0 gate", () => {
-    it("allows a community non-official executable only through L0 launcher with audit metadata", () => {
-        const sandbox = createSkillSandbox({
-            availability: {
-                level: "L0",
-                available: true,
-                backend: "windows-process-tree-launcher",
-                platform: "win32",
-            },
-        });
-        expect(sandbox.decide({
-            origin: "community",
-            official: false,
-            riskTier: "R0",
-            executable: true,
-            autoRun: true,
-        })).toMatchObject({
-            allowed: true,
-            spawnAllowed: true,
-            launcherRequired: true,
-            reason: "launcher-required",
-            backend: "community-l0-launcher",
-            launcher: {
-                level: "L0",
-                mode: "os-native-launcher",
-                defaultHostAccess: true,
-                noFsNetworkRestriction: true,
-                audit: {
-                    envelope: "l0-launcher-audit-v1",
-                    subject: {
-                        origin: "community",
-                        official: false,
-                        executable: true,
-                        autoRun: true,
-                    },
-                    decision: "allowed",
-                    reason: "launcher-required",
-                },
-            },
-        });
-    });
-    it("fails closed for community non-official executable when L0 launcher is unavailable", () => {
-        const sandbox = createSkillSandbox({
-            availability: {
-                level: "L0",
-                available: false,
-                backend: "unavailable",
-                platform: "win32",
-                reason: "windows-l0-not-provisioned",
-            },
-        });
-        expect(sandbox.decide({
-            origin: "community",
-            official: false,
-            riskTier: "R0",
-            executable: true,
-            autoRun: true,
-        })).toMatchObject({
-            allowed: false,
-            spawnAllowed: false,
-            launcherRequired: true,
-            reason: "launcher-unavailable",
-            backend: "community-l0-launcher",
-            launcher: {
-                defaultHostAccess: true,
-                noFsNetworkRestriction: true,
-                audit: {
-                    envelope: "l0-launcher-audit-v1",
-                    decision: "blocked",
-                    reason: "launcher-unavailable",
-                },
-            },
-        });
-    });
-    it("does not route official actions through the community launcher requirement", () => {
-        const sandbox = createSkillSandbox({
-            availability: {
-                level: "L0",
-                available: false,
-                backend: "unavailable",
-                platform: "win32",
-                reason: "windows-l0-not-provisioned",
-            },
-        });
-        expect(sandbox.decide({
-            origin: "official",
-            riskTier: "R3",
-            executable: true,
-            autoRun: true,
-        })).toMatchObject({
-            allowed: true,
-            reason: "first-party-action",
-            backend: "first-party",
-            launcherRequired: false,
-        });
-    });
-    it("builds Windows process-tree launcher metadata without claiming Job Object containment", () => {
-        const metadata = buildWindowsSandboxLaunchMetadata({
-            command: "skill-runner.exe",
-            args: ["--skill", "community-demo"],
-        });
-        expect(metadata).toMatchObject({
-            backend: "windows-process-tree-launcher",
-            command: "skill-runner.exe",
-            args: ["--skill", "community-demo"],
-            elevated: false,
-            defaultHostAccess: true,
-            noFsNetworkRestriction: true,
-            jobObject: {
-                implemented: false,
-                ready: true,
-            },
-            processTree: {
-                killOnClose: true,
-                trackChildren: true,
-                terminateOnLauncherClose: true,
-            },
-            audit: {
-                envelope: "l0-launcher-audit-v1",
-                lifecycle: ["launch-requested", "process-started", "process-exited", "tree-kill-requested"],
-            },
-        });
-    });
-    it("launches through the Windows process-tree launcher and kills the tree on close", async () => {
-        const spawned = [];
-        const killedTrees = [];
-        const launcher = createWindowsProcessTreeLauncher({
-            spawn(command, args) {
-                spawned.push({ command, args });
-                return { pid: 42 };
-            },
-            async killProcessTree(pid) {
-                killedTrees.push(pid);
-            },
-        });
-        const handle = launcher.launch({
-            command: "skill-runner.exe",
-            args: ["--skill", "community-demo"],
-        });
-        expect(spawned).toEqual([{ command: "skill-runner.exe", args: ["--skill", "community-demo"] }]);
-        expect(handle).toMatchObject({
-            pid: 42,
-            metadata: {
-                backend: "windows-process-tree-launcher",
-                processTree: {
-                    killOnClose: true,
-                    trackChildren: true,
-                },
-            },
-            auditEvents: ["launch-requested", "process-started"],
-        });
-        await handle.close();
-        expect(killedTrees).toEqual([42]);
-        expect(handle.auditEvents).toEqual(["launch-requested", "process-started", "tree-kill-requested"]);
-    });
-    it("records launch failure in the audit envelope when spawn fails", () => {
-        const launcher = createWindowsProcessTreeLauncher({
-            spawn() {
-                throw new Error("spawn denied");
-            },
-            killProcessTree: vi.fn(),
-        });
-        expect(() => launcher.launch({
-            command: "skill-runner.exe",
-            args: [],
-        })).toThrow("spawn denied");
-        expect(launcher.auditEvents).toEqual(["launch-requested", "launch-failed"]);
-    });
-});

package/dist/runtime/sandbox/windows-skill-sandbox.d.ts

@@ -1,78 +0,0 @@
-export type WindowsSkillSandboxBackend = "windows-process-tree-launcher";
-export type WindowsProcessTreeLauncherAuditEvent = "launch-requested" | "process-started" | "process-exited" | "tree-kill-requested" | "launch-failed";
-export interface WindowsSkillSandboxAvailabilityOptions {
-    platform?: string;
-    appContainerAvailable?: boolean;
-    jobObjectAvailable?: boolean;
-    processTreeLauncherAvailable?: boolean;
-}
-export interface WindowsSkillSandboxAvailability {
-    level: "L0";
-    available: boolean;
-    backend: WindowsSkillSandboxBackend | "unsupported-platform" | "unavailable";
-    platform: string;
-    reason?: "unsupported-platform" | "windows-l0-not-provisioned";
-}
-export interface WindowsSandboxLaunchMetadata {
-    backend: WindowsSkillSandboxBackend;
-    command: string;
-    args: string[];
-    elevated: false;
-    defaultHostAccess: true;
-    noFsNetworkRestriction: true;
-    jobObject: {
-        implemented: false;
-        ready: true;
-    };
-    processTree: {
-        killOnClose: true;
-        trackChildren: true;
-        terminateOnLauncherClose: true;
-    };
-    audit: {
-        envelope: "l0-launcher-audit-v1";
-        lifecycle: WindowsProcessTreeLauncherAuditEvent[];
-    };
-}
-export interface WindowsProcessTreeLauncherAuditEnvelope {
-    envelope: "l0-launcher-audit-v1";
-    backend: WindowsSkillSandboxBackend;
-    defaultHostAccess: true;
-    noFsNetworkRestriction: true;
-    processTree: {
-        killOnClose: true;
-        trackChildren: true;
-    };
-    jobObject: {
-        implemented: false;
-        ready: true;
-    };
-}
-export interface WindowsProcessTreeChild {
-    pid?: number;
-}
-export interface WindowsProcessTreeLauncherDependencies {
-    spawn?: (command: string, args: string[]) => WindowsProcessTreeChild;
-    killProcessTree?: (pid: number) => Promise<void> | void;
-}
-export interface WindowsProcessTreeLaunchRequest {
-    command: string;
-    args?: string[];
-}
-export interface WindowsProcessTreeLaunchHandle {
-    pid: number;
-    metadata: WindowsSandboxLaunchMetadata;
-    auditEvents: WindowsProcessTreeLauncherAuditEvent[];
-    close(): Promise<void>;
-}
-export interface WindowsProcessTreeLauncher {
-    auditEvents: WindowsProcessTreeLauncherAuditEvent[];
-    launch(request: WindowsProcessTreeLaunchRequest): WindowsProcessTreeLaunchHandle;
-}
-export declare function getWindowsSkillSandboxAvailability(options?: WindowsSkillSandboxAvailabilityOptions): WindowsSkillSandboxAvailability;
-export declare function buildWindowsSandboxLaunchMetadata(input: {
-    command: string;
-    args?: string[];
-}): WindowsSandboxLaunchMetadata;
-export declare function buildWindowsProcessTreeLauncherAuditEnvelope(): WindowsProcessTreeLauncherAuditEnvelope;
-export declare function createWindowsProcessTreeLauncher(dependencies?: WindowsProcessTreeLauncherDependencies): WindowsProcessTreeLauncher;

package/dist/runtime/sandbox/windows-skill-sandbox.js

@@ -1,128 +0,0 @@
-import { spawn as spawnChildProcess } from "node:child_process";
-export function getWindowsSkillSandboxAvailability(options = {}) {
-    const platform = options.platform ?? process.platform;
-    if (platform !== "win32") {
-        return {
-            level: "L0",
-            available: false,
-            backend: "unsupported-platform",
-            platform,
-            reason: "unsupported-platform",
-        };
-    }
-    const available = options.processTreeLauncherAvailable === true
-        || options.jobObjectAvailable === true;
-    return {
-        level: "L0",
-        available,
-        backend: available ? "windows-process-tree-launcher" : "unavailable",
-        platform,
-        reason: available ? undefined : "windows-l0-not-provisioned",
-    };
-}
-export function buildWindowsSandboxLaunchMetadata(input) {
-    return {
-        backend: "windows-process-tree-launcher",
-        command: input.command,
-        args: input.args ?? [],
-        elevated: false,
-        defaultHostAccess: true,
-        noFsNetworkRestriction: true,
-        jobObject: {
-            implemented: false,
-            ready: true,
-        },
-        processTree: {
-            killOnClose: true,
-            trackChildren: true,
-            terminateOnLauncherClose: true,
-        },
-        audit: {
-            envelope: "l0-launcher-audit-v1",
-            lifecycle: ["launch-requested", "process-started", "process-exited", "tree-kill-requested"],
-        },
-    };
-}
-export function buildWindowsProcessTreeLauncherAuditEnvelope() {
-    return {
-        envelope: "l0-launcher-audit-v1",
-        backend: "windows-process-tree-launcher",
-        defaultHostAccess: true,
-        noFsNetworkRestriction: true,
-        processTree: {
-            killOnClose: true,
-            trackChildren: true,
-        },
-        jobObject: {
-            implemented: false,
-            ready: true,
-        },
-    };
-}
-export function createWindowsProcessTreeLauncher(dependencies = {}) {
-    const auditEvents = [];
-    const spawn = dependencies.spawn ?? defaultSpawn;
-    const killProcessTree = dependencies.killProcessTree ?? defaultKillProcessTree;
-    return {
-        auditEvents,
-        launch(request) {
-            const metadata = buildWindowsSandboxLaunchMetadata(request);
-            auditEvents.push("launch-requested");
-            let child;
-            try {
-                child = spawn(metadata.command, metadata.args);
-            }
-            catch (error) {
-                auditEvents.push("launch-failed");
-                throw error;
-            }
-            if (typeof child.pid !== "number") {
-                auditEvents.push("launch-failed");
-                throw new Error("windows process-tree launcher spawn did not return a pid");
-            }
-            auditEvents.push("process-started");
-            return {
-                pid: child.pid,
-                metadata,
-                auditEvents,
-                async close() {
-                    auditEvents.push("tree-kill-requested");
-                    await killProcessTree(child.pid);
-                },
-            };
-        },
-    };
-}
-function defaultSpawn(command, args) {
-    return spawnChildProcess(command, args, {
-        detached: false,
-        stdio: "ignore",
-        windowsHide: true,
-    });
-}
-async function defaultKillProcessTree(pid) {
-    if (process.platform === "win32") {
-        await new Promise((resolve, reject) => {
-            const killer = spawnChildProcess("taskkill", ["/PID", String(pid), "/T", "/F"], {
-                stdio: "ignore",
-                windowsHide: true,
-            });
-            killer.once("error", reject);
-            killer.once("exit", (code) => {
-                if (code === 0) {
-                    resolve();
-                    return;
-                }
-                reject(new Error(`taskkill exited with code ${code ?? "unknown"}`));
-            });
-        });
-        return;
-    }
-    try {
-        process.kill(pid);
-    }
-    catch (error) {
-        if (error.code !== "ESRCH")
-            throw error;
-    }
-}

package/dist/runtime/session/group-session-split.d.ts

@@ -1,38 +0,0 @@
-/**
- * Group Session Auto-Split — detects idle group sessions and creates successor sessions.
- *
- * When a group chat message arrives and the last session activity was > N hours ago,
- * the old session is sealed and a new session is created with:
- *   - previousSessionId linking to the predecessor
- *   - carryoverSummary (from predecessor's taskSummary or last messages)
- *   - Same groupKey, groupName, groupPlatform, projectId
- *
- * This prevents unbounded context growth in long-lived group chats.
- */
-import { type SessionMetadata } from "./session-persistence.js";
-export interface GroupSplitResult {
-    /** Whether a split occurred */
-    split: boolean;
-    /** The session ID to use for the current turn (new or existing) */
-    activeSessionId: string;
-    /** If split, the sealed predecessor session ID */
-    sealedSessionId?: string;
-}
-/**
- * Check whether a group session should be auto-split due to idle timeout.
- * If yes, seal the old session and create a new successor.
- *
- * @param currentSession - The existing group session metadata
- * @param projectRoot - The project workspace directory
- * @returns Split result with the session ID to use
- */
-export declare function maybeAutoSplitGroupSession(currentSession: SessionMetadata, projectRoot: string): Promise<GroupSplitResult>;
-/**
- * Check whether a group session has exceeded MAX_TURNS hard limit.
- * Called AFTER turn.end — soft-splits without interrupting the current turn.
- *
- * @param currentSession - The session that just finished a turn
- * @param projectRoot - The project workspace directory
- * @returns Split result (new session ready for next message, or no-op)
- */
-export declare function maybeHardLimitSplit(currentSession: SessionMetadata, projectRoot: string): Promise<GroupSplitResult>;

package/dist/runtime/session/group-session-split.js

@@ -1,99 +0,0 @@
-/**
- * Group Session Auto-Split — detects idle group sessions and creates successor sessions.
- *
- * When a group chat message arrives and the last session activity was > N hours ago,
- * the old session is sealed and a new session is created with:
- *   - previousSessionId linking to the predecessor
- *   - carryoverSummary (from predecessor's taskSummary or last messages)
- *   - Same groupKey, groupName, groupPlatform, projectId
- *
- * This prevents unbounded context growth in long-lived group chats.
- */
-import { randomUUID } from "node:crypto";
-import { GROUP_SESSION_IDLE_THRESHOLD_MS, GROUP_SESSION_MAX_TURNS } from "../config/tunable-defaults.js";
-import { updateSessionMetadata } from "./session-persistence.js";
-/**
- * Check whether a group session should be auto-split due to idle timeout.
- * If yes, seal the old session and create a new successor.
- *
- * @param currentSession - The existing group session metadata
- * @param projectRoot - The project workspace directory
- * @returns Split result with the session ID to use
- */
-export async function maybeAutoSplitGroupSession(currentSession, projectRoot) {
-    const lastActive = new Date(currentSession.lastActiveAt).getTime();
-    const now = Date.now();
-    const idleDuration = now - lastActive;
-    if (idleDuration < GROUP_SESSION_IDLE_THRESHOLD_MS) {
-        return { split: false, activeSessionId: currentSession.sessionId };
-    }
-    // Idle threshold exceeded — seal old session and create new one
-    const newSessionId = randomUUID();
-    const nowIso = new Date().toISOString();
-    // Seal the old session
-    await updateSessionMetadata(currentSession.sessionId, {
-        sealedAt: nowIso,
-    }, projectRoot);
-    // Derive carryover summary from the old session's taskSummary (if available)
-    const carryoverSummary = currentSession.taskSummary
-        ? `[上一轮对话摘要] ${currentSession.taskSummary}`
-        : undefined;
-    // Create the new successor session
-    await updateSessionMetadata(newSessionId, {
-        sessionId: newSessionId,
-        projectId: currentSession.projectId,
-        type: "group",
-        ownerId: currentSession.ownerId,
-        groupKey: currentSession.groupKey,
-        groupName: currentSession.groupName,
-        groupPlatform: currentSession.groupPlatform,
-        previousSessionId: currentSession.sessionId,
-        carryoverSummary,
-    }, projectRoot);
-    return {
-        split: true,
-        activeSessionId: newSessionId,
-        sealedSessionId: currentSession.sessionId,
-    };
-}
-/**
- * Check whether a group session has exceeded MAX_TURNS hard limit.
- * Called AFTER turn.end — soft-splits without interrupting the current turn.
- *
- * @param currentSession - The session that just finished a turn
- * @param projectRoot - The project workspace directory
- * @returns Split result (new session ready for next message, or no-op)
- */
-export async function maybeHardLimitSplit(currentSession, projectRoot) {
-    if (currentSession.type !== "group") {
-        return { split: false, activeSessionId: currentSession.sessionId };
-    }
-    if (currentSession.turnCount < GROUP_SESSION_MAX_TURNS) {
-        return { split: false, activeSessionId: currentSession.sessionId };
-    }
-    // Hard limit exceeded — seal and create successor
-    const newSessionId = randomUUID();
-    const nowIso = new Date().toISOString();
-    await updateSessionMetadata(currentSession.sessionId, {
-        sealedAt: nowIso,
-    }, projectRoot);
-    const carryoverSummary = currentSession.taskSummary
-        ? `[上一轮对话摘要 — 因消息数达到上限自动切分] ${currentSession.taskSummary}`
-        : undefined;
-    await updateSessionMetadata(newSessionId, {
-        sessionId: newSessionId,
-        projectId: currentSession.projectId,
-        type: "group",
-        ownerId: currentSession.ownerId,
-        groupKey: currentSession.groupKey,
-        groupName: currentSession.groupName,
-        groupPlatform: currentSession.groupPlatform,
-        previousSessionId: currentSession.sessionId,
-        carryoverSummary,
-    }, projectRoot);
-    return {
-        split: true,
-        activeSessionId: newSessionId,
-        sealedSessionId: currentSession.sessionId,
-    };
-}

package/dist/runtime/session/index.d.ts

@@ -1,4 +0,0 @@
-export { SessionState, type SessionUsageSnapshot } from "./session-state.js";
-export { SessionLocator } from "./session-locator.js";
-export { appendMessage, saveSessionState, updateSessionMetadata, getSessionMetadata, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, type SessionMetadata, type PersistedSession, type SessionListEntry, type TaskSummaryDeps, } from "./session-persistence.js";
-export { maybeAutoSplitGroupSession, type GroupSplitResult } from "./group-session-split.js";

package/dist/runtime/session/index.js

@@ -1,5 +0,0 @@
-// runtime/session — session lifecycle subsystem
-export { SessionState } from "./session-state.js";
-export { SessionLocator } from "./session-locator.js";
-export { appendMessage, saveSessionState, updateSessionMetadata, getSessionMetadata, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, } from "./session-persistence.js";
-export { maybeAutoSplitGroupSession } from "./group-session-split.js";

package/dist/runtime/session/session-catalog.d.ts

@@ -1,4 +0,0 @@
-import type { SessionListEntry } from "./session-types.js";
-export declare function listSessions(limit: number | undefined, projectRoot: string): Promise<SessionListEntry[]>;
-export declare function deleteSession(sessionId: string, projectRoot: string): Promise<void>;
-export declare function pruneOldSessions(projectRoot: string): Promise<number>;

package/dist/runtime/session/session-catalog.js

@@ -1,59 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { MAX_SESSIONS } from "../config/tunable-defaults.js";
-import { getSessionDir, getSessionsRoot, METADATA_FILE, } from "./session-paths.js";
-import { normalizeSessionMetadata } from "./session-schema.js";
-export async function listSessions(limit = MAX_SESSIONS, projectRoot) {
-    let entries;
-    try {
-        entries = await fs.promises.readdir(getSessionsRoot(projectRoot));
-    }
-    catch {
-        return [];
-    }
-    const sessions = [];
-    for (const entry of entries) {
-        const metaPath = path.join(getSessionsRoot(projectRoot), entry, METADATA_FILE);
-        try {
-            const raw = await fs.promises.readFile(metaPath, "utf8");
-            sessions.push(toListEntry(normalizeSessionMetadata(entry, JSON.parse(raw))));
-        }
-        catch {
-            // Corrupted session metadata is skipped from the picker.
-        }
-    }
-    sessions.sort((a, b) => (a.lastActiveAt > b.lastActiveAt ? -1 : a.lastActiveAt < b.lastActiveAt ? 1 : 0));
-    return sessions.slice(0, limit);
-}
-export async function deleteSession(sessionId, projectRoot) {
-    await fs.promises.rm(getSessionDir(sessionId, projectRoot), { recursive: true, force: true });
-}
-export async function pruneOldSessions(projectRoot) {
-    const sessions = await listSessions(MAX_SESSIONS * 2, projectRoot);
-    if (sessions.length <= MAX_SESSIONS)
-        return 0;
-    const toDelete = sessions.slice(MAX_SESSIONS);
-    for (const session of toDelete) {
-        await deleteSession(session.sessionId, projectRoot);
-    }
-    return toDelete.length;
-}
-function toListEntry(meta) {
-    return {
-        sessionId: meta.sessionId,
-        title: meta.title,
-        lastActiveAt: meta.lastActiveAt,
-        messageCount: meta.messageCount,
-        model: meta.model,
-        agentId: meta.agentId,
-        pinnedAt: meta.pinnedAt,
-        archivedAt: meta.archivedAt,
-        sealedAt: meta.sealedAt,
-        projectId: meta.projectId,
-        type: meta.type ?? "personal",
-        createdAt: meta.createdAt,
-        groupKey: meta.groupKey,
-        previousSessionId: meta.previousSessionId,
-        carryoverSummary: meta.carryoverSummary ?? null,
-    };
-}

package/dist/runtime/session/session-locator.d.ts

@@ -1,26 +0,0 @@
-/**
- * SessionLocator — resolves session storage paths from projectId.
- *
- * Every session operation uses this locator to determine the correct
- * filesystem path based on the session's owning projectId.
- * When projectId is missing, falls back to scanning all projects.
- */
-export declare class SessionLocator {
-    /** Get sessions root directory for a given projectId. */
-    getSessionsRoot(projectId: string): string;
-    /** Get the workspace dir for a project. */
-    getProjectWorkspaceDir(projectId: string): string;
-    /** Get the session directory path for a given projectId + sessionId. */
-    getSessionDir(projectId: string, sessionId: string): string;
-    /**
-     * Resolve the workspaceDir for a session given its projectId.
-     * If projectId is not provided, scans all projects for the session directory.
-     */
-    resolveWorkspaceDir(sessionId: string, projectId?: string): string;
-    /** Get the active project's workspace dir (for new session creation when no projectId specified). */
-    getActiveProjectWorkspaceDir(): string;
-    /** Get the active project's ID. */
-    getActiveProjectId(): string;
-    /** Get the default project's ID for external personal channel sessions. */
-    getDefaultProjectId(): string;
-}