qlogicagent 2.13.4 → 2.13.5

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

@@ -0,0 +1,172 @@
+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

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,128 @@
+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

@@ -0,0 +1,38 @@
+/**
+ * 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

@@ -0,0 +1,99 @@
+/**
+ * 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,5 @@
+// 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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,26 @@
+/**
+ * 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;
+}