qlogicagent 2.13.4 → 2.13.5

package/dist/runtime/infra/agent-install-runner.test.js

@@ -0,0 +1,103 @@
+import { describe, expect, it } from "vitest";
+import { applyInstallMirror, pickInstallCommand, runAgentInstall, } from "./agent-install-runner.js";
+function fakeProc(code, logs) {
+    const stdoutCbs = [];
+    return {
+        stdout: { on: (_e, cb) => stdoutCbs.push(cb) },
+        stderr: { on: () => { } },
+        on: (ev, cb) => {
+            if (ev === "close") {
+                queueMicrotask(() => {
+                    for (const l of logs)
+                        stdoutCbs.forEach((c) => c(l));
+                    cb(code);
+                });
+            }
+        },
+    };
+}
+function makeSpawn(results) {
+    let i = 0;
+    return () => {
+        const r = results[i++] ?? { code: 0 };
+        return fakeProc(r.code, r.logs ?? []);
+    };
+}
+const SPEC = { npm: "npm i -g pkg", cliCommand: "pkg", docsUrl: "https://x" };
+describe("pickInstallCommand", () => {
+    it("prefers brew on macOS", () => {
+        expect(pickInstallCommand({ ...SPEC, brew: "brew install pkg" }, "darwin")?.command).toBe("brew install pkg");
+    });
+    it("prefers npm on Windows/Linux", () => {
+        expect(pickInstallCommand({ ...SPEC, brew: "brew install pkg" }, "win32")?.command).toBe("npm i -g pkg");
+        expect(pickInstallCommand({ ...SPEC, brew: "brew install pkg" }, "linux")?.command).toBe("npm i -g pkg");
+    });
+    it("flags curl pipelines as shell, and skips them on Windows", () => {
+        const curlOnly = { cliCommand: "pkg", docsUrl: "https://x", curl: "curl https://x | bash" };
+        expect(pickInstallCommand(curlOnly, "linux")).toEqual({ command: "curl https://x | bash", shell: true });
+        expect(pickInstallCommand(curlOnly, "win32")).toBeNull();
+    });
+});
+describe("runAgentInstall", () => {
+    it("install ok → verify ok → installed", async () => {
+        const events = [];
+        const res = await runAgentInstall(SPEC, (e) => events.push(e), {
+            platform: "linux",
+            spawnImpl: makeSpawn([{ code: 0, logs: ["installing…\n"] }, { code: 0 }]),
+        });
+        expect(res.ok).toBe(true);
+        expect(events.map((e) => (e.type === "state" ? e.state : e.type))).toEqual([
+            "installing", "log", "verifying", "installed", "done",
+        ]);
+    });
+    it("install failure → failed, verify not attempted", async () => {
+        const events = [];
+        const res = await runAgentInstall(SPEC, (e) => events.push(e), {
+            platform: "linux",
+            spawnImpl: makeSpawn([{ code: 1 }]),
+        });
+        expect(res.ok).toBe(false);
+        expect(events.some((e) => e.type === "state" && e.state === "verifying")).toBe(false);
+        expect(events.at(-1)).toMatchObject({ type: "done", ok: false });
+    });
+    it("verify failure → failed", async () => {
+        const res = await runAgentInstall(SPEC, () => { }, {
+            platform: "linux",
+            spawnImpl: makeSpawn([{ code: 0 }, { code: 1 }]),
+        });
+        expect(res.ok).toBe(false);
+        expect(res.error).toMatch(/verification failed/);
+    });
+    it("no platform command → failed without spawning", async () => {
+        const res = await runAgentInstall({ cliCommand: "pkg", docsUrl: "https://x", curl: "curl x | bash" }, () => { }, { platform: "win32", spawnImpl: makeSpawn([]) });
+        expect(res.ok).toBe(false);
+        expect(res.error).toMatch(/No install command/);
+    });
+    it("applies the opt-in mirror to the install command it runs", async () => {
+        const commands = [];
+        const spawnImpl = (command) => { commands.push(command); return fakeProc(0, []); };
+        await runAgentInstall(SPEC, () => { }, { platform: "linux", spawnImpl, mirror: "cn" });
+        expect(commands[0]).toBe("npm i -g pkg --registry https://registry.npmmirror.com");
+    });
+});
+describe("applyInstallMirror", () => {
+    it("is off by default — command unchanged", () => {
+        expect(applyInstallMirror("npm i -g pkg", undefined)).toBe("npm i -g pkg");
+        expect(applyInstallMirror("uv tool install kimi-cli", "")).toBe("uv tool install kimi-cli");
+    });
+    it("cn: rewrites npm → npmmirror, uv → tsinghua, pipx/pip → tsinghua", () => {
+        expect(applyInstallMirror("npm i -g pkg", "cn")).toBe("npm i -g pkg --registry https://registry.npmmirror.com");
+        expect(applyInstallMirror("uv tool install kimi-cli", "cn")).toBe("uv tool install kimi-cli --default-index https://pypi.tuna.tsinghua.edu.cn/simple");
+        expect(applyInstallMirror("pipx install some-pkg", "cn")).toBe("pipx install some-pkg --index-url https://pypi.tuna.tsinghua.edu.cn/simple");
+    });
+    it("cn: does not double-inject when a registry/index is already pinned", () => {
+        const npmPinned = "npm i -g pkg --registry https://example.com";
+        const uvPinned = "uv tool install kimi-cli --default-index https://x";
+        expect(applyInstallMirror(npmPinned, "cn")).toBe(npmPinned);
+        expect(applyInstallMirror(uvPinned, "cn")).toBe(uvPinned);
+    });
+    it("cn: leaves curl/brew commands untouched", () => {
+        expect(applyInstallMirror("curl https://x | bash", "cn")).toBe("curl https://x | bash");
+        expect(applyInstallMirror("brew install pkg", "cn")).toBe("brew install pkg");
+    });
+});

package/dist/runtime/infra/agent-paths.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Agent Paths — Centralized dot-directory name and path helpers.
+ *
+ * All filesystem paths under `~/.qlogicagent/` (user-level) or
+ * `<project>/.qlogicagent/` (project-level) must go through these
+ * helpers so the dot-dir name is defined in exactly one place.
+ */
+/** Dot-directory name used for both user-level and project-level storage. */
+export declare const AGENT_DOT_DIR = ".qlogicagent";
+/** `~/.qlogicagent/` (or QLOGICAGENT_HOME override) */
+export declare function getUserAgentHome(): string;
+export declare function resolveActiveOwnerUserId(): string;
+export declare function encodeOwnerProfileSegment(ownerUserId: string): string;
+export declare function getOwnerProfileDir(ownerUserId?: string): string;
+export declare function getProfileMemoryDir(ownerUserId?: string): string;
+/**
+ * Ensure the user agent home directory exists and is writable.
+ * Returns the path if accessible, throws with a friendly message otherwise.
+ * Call this once at startup rather than on every path resolution.
+ */
+export declare function ensureUserAgentHome(): string;
+/** `~/.qlogicagent/profiles/<owner>/.credentials.json` */
+export declare function getUserCredentialsPath(): string;
+/** `~/.qlogicagent/profiles/<owner>/plugins/` */
+export declare function getUserPluginsDir(): string;
+/** `~/.qlogicagent/profiles/<owner>/skills/` */
+export declare function getUserSkillsDir(): string;
+/** `~/.qlogicagent/profiles/<owner>/settings.json` */
+export declare function getUserSettingsPath(): string;
+/** `~/.qlogicagent/cache/` */
+export declare function getUserCacheDir(): string;
+/** `~/.qlogicagent/debug-logs/` */
+export declare function getUserDebugLogsDir(): string;
+/** `~/.qlogicagent/profiles/<owner>/plugin-cache/` */
+export declare function getUserPluginCacheDir(): string;
+/** `~/.qlogicagent/profiles/<owner>/mcp.json` */
+export declare function getUserMcpConfigPath(): string;
+/** `~/.qlogicagent/profiles/<owner>/marketplace.json` */
+export declare function getUserMarketplaceConfigPath(): string;
+/** `~/.qlogicagent/profiles/<owner>/workflows/` */
+export declare function getUserWorkflowsDir(): string;
+/** `~/.qlogicagent/profiles/<owner>/INSTRUCTIONS.md` */
+export declare function getUserInstructionsPath(): string;
+/** `~/.qlogicagent/profiles/<owner>/rules/` */
+export declare function getUserRulesDir(): string;
+/** `<cwd>/.qlogicagent/` */
+export declare function getProjectAgentDir(cwd: string): string;
+/** `<cwd>/.qlogicagent/workflows/` */
+export declare function getProjectWorkflowsDir(cwd: string): string;
+/** `<cwd>/.qlogicagent/plugins/` */
+export declare function getProjectPluginsDir(cwd: string): string;
+/** `<cwd>/.qlogicagent/skills-enabled.json` — per-project skill enablement manifest. */
+export declare function getProjectSkillManifestPath(cwd: string): string;
+/** `<cwd>/.qlogicagent/settings.json` */
+export declare function getProjectSettingsPath(cwd: string): string;
+/** `<cwd>/.qlogicagent/INSTRUCTIONS.md` */
+export declare function getProjectInstructionsPath(cwd: string): string;
+/** `<cwd>/.qlogicagent/rules/` — unified rules + instructions directory */
+export declare function getProjectRulesDir(cwd: string): string;
+/** `<cwd>/.qlogicagent/sessions/` */
+export declare function getProjectSessionsRoot(cwd: string): string;
+/** `<cwd>/.qlogicagent/sessions/{sessionId}` */
+export declare function getProjectSessionDir(cwd: string, sessionId: string): string;
+/** `<cwd>/.qlogicagent/checkpoints/` or `<cwd>/.qlogicagent/checkpoints/{sessionId}` */
+export declare function getProjectCheckpointsDir(cwd: string, sessionId?: string): string;
+/** `<gitRoot>/.qlogicagent/hooks/` */
+export declare function getGitRootHooksDir(gitRoot: string): string;

package/dist/runtime/infra/agent-paths.js

@@ -0,0 +1,167 @@
+/**
+ * Agent Paths — Centralized dot-directory name and path helpers.
+ *
+ * All filesystem paths under `~/.qlogicagent/` (user-level) or
+ * `<project>/.qlogicagent/` (project-level) must go through these
+ * helpers so the dot-dir name is defined in exactly one place.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+// ── The single source of truth ──────────────────────────────
+/** Dot-directory name used for both user-level and project-level storage. */
+export const AGENT_DOT_DIR = ".qlogicagent";
+// ── User-level paths (~/.qlogicagent/) ──────────────────────
+/** `~/.qlogicagent/` (or QLOGICAGENT_HOME override) */
+export function getUserAgentHome() {
+    return process.env.QLOGICAGENT_HOME || join(homedir(), AGENT_DOT_DIR);
+}
+export function resolveActiveOwnerUserId() {
+    const llmrouterUserId = process.env.QLOGIC_LLMROUTER_USER_ID?.trim();
+    if (llmrouterUserId)
+        return llmrouterUserId;
+    const implicitOwnerId = process.env.QLOGIC_IMPLICIT_OWNER_ID?.trim();
+    if (implicitOwnerId)
+        return implicitOwnerId;
+    const deviceId = process.env.QLOGIC_DEVICE_ID?.trim();
+    if (deviceId)
+        return `oc_${deviceId}`;
+    return "oc_local";
+}
+export function encodeOwnerProfileSegment(ownerUserId) {
+    const owner = ownerUserId.trim();
+    if (!owner)
+        throw new Error("ownerUserId is required for profile-scoped storage");
+    return encodeURIComponent(owner).replace(/\./g, "%2E");
+}
+export function getOwnerProfileDir(ownerUserId = resolveActiveOwnerUserId()) {
+    return join(getUserAgentHome(), "profiles", encodeOwnerProfileSegment(ownerUserId));
+}
+export function getProfileMemoryDir(ownerUserId = resolveActiveOwnerUserId()) {
+    return join(getOwnerProfileDir(ownerUserId), "memory");
+}
+/**
+ * Ensure the user agent home directory exists and is writable.
+ * Returns the path if accessible, throws with a friendly message otherwise.
+ * Call this once at startup rather than on every path resolution.
+ */
+export function ensureUserAgentHome() {
+    const home = getUserAgentHome();
+    try {
+        if (!existsSync(home)) {
+            const { mkdirSync } = require("node:fs");
+            mkdirSync(home, { recursive: true });
+        }
+        // Verify write access by touching a temp file
+        const testFile = join(home, ".write-test");
+        const fs = require("node:fs");
+        fs.writeFileSync(testFile, "", "utf8");
+        fs.unlinkSync(testFile);
+        return home;
+    }
+    catch (err) {
+        throw new Error(`Cannot access agent home directory "${home}": ${err.message}. ` +
+            `Check permissions or set QLOGICAGENT_HOME to a writable directory.`);
+    }
+}
+/** `~/.qlogicagent/profiles/<owner>/.credentials.json` */
+export function getUserCredentialsPath() {
+    return join(getOwnerProfileDir(), ".credentials.json");
+}
+/** `~/.qlogicagent/profiles/<owner>/plugins/` */
+export function getUserPluginsDir() {
+    return join(getOwnerProfileDir(), "plugins");
+}
+/** `~/.qlogicagent/profiles/<owner>/skills/` */
+export function getUserSkillsDir() {
+    return join(getOwnerProfileDir(), "skills");
+}
+/** `~/.qlogicagent/profiles/<owner>/settings.json` */
+export function getUserSettingsPath() {
+    return join(getOwnerProfileDir(), "settings.json");
+}
+/** `~/.qlogicagent/cache/` */
+export function getUserCacheDir() {
+    return join(getUserAgentHome(), "cache");
+}
+/** `~/.qlogicagent/debug-logs/` */
+export function getUserDebugLogsDir() {
+    return join(getUserAgentHome(), "debug-logs");
+}
+/** `~/.qlogicagent/profiles/<owner>/plugin-cache/` */
+export function getUserPluginCacheDir() {
+    return join(getOwnerProfileDir(), "plugin-cache");
+}
+/** `~/.qlogicagent/profiles/<owner>/mcp.json` */
+export function getUserMcpConfigPath() {
+    return join(getOwnerProfileDir(), "mcp.json");
+}
+/** `~/.qlogicagent/profiles/<owner>/marketplace.json` */
+export function getUserMarketplaceConfigPath() {
+    return join(getOwnerProfileDir(), "marketplace.json");
+}
+/** `~/.qlogicagent/profiles/<owner>/workflows/` */
+export function getUserWorkflowsDir() {
+    return join(getOwnerProfileDir(), "workflows");
+}
+/** `~/.qlogicagent/profiles/<owner>/INSTRUCTIONS.md` */
+export function getUserInstructionsPath() {
+    return join(getOwnerProfileDir(), "INSTRUCTIONS.md");
+}
+/** `~/.qlogicagent/profiles/<owner>/rules/` */
+export function getUserRulesDir() {
+    return join(getOwnerProfileDir(), "rules");
+}
+// ── Project-level paths (<cwd>/.qlogicagent/) ───────────────
+/** `<cwd>/.qlogicagent/` */
+export function getProjectAgentDir(cwd) {
+    if (!cwd) {
+        throw new Error("getProjectAgentDir: cwd is required (must not fall back to process.cwd())");
+    }
+    return join(cwd, AGENT_DOT_DIR);
+}
+/** `<cwd>/.qlogicagent/workflows/` */
+export function getProjectWorkflowsDir(cwd) {
+    return join(getProjectAgentDir(cwd), "workflows");
+}
+/** `<cwd>/.qlogicagent/plugins/` */
+export function getProjectPluginsDir(cwd) {
+    return join(getProjectAgentDir(cwd), "plugins");
+}
+/** `<cwd>/.qlogicagent/skills-enabled.json` — per-project skill enablement manifest. */
+export function getProjectSkillManifestPath(cwd) {
+    return join(getProjectAgentDir(cwd), "skills-enabled.json");
+}
+/** `<cwd>/.qlogicagent/settings.json` */
+export function getProjectSettingsPath(cwd) {
+    return join(getProjectAgentDir(cwd), "settings.json");
+}
+/** `<cwd>/.qlogicagent/INSTRUCTIONS.md` */
+export function getProjectInstructionsPath(cwd) {
+    return join(getProjectAgentDir(cwd), "INSTRUCTIONS.md");
+}
+/** `<cwd>/.qlogicagent/rules/` — unified rules + instructions directory */
+export function getProjectRulesDir(cwd) {
+    return join(getProjectAgentDir(cwd), "rules");
+}
+/** `<cwd>/.qlogicagent/sessions/` */
+export function getProjectSessionsRoot(cwd) {
+    return join(getProjectAgentDir(cwd), "sessions");
+}
+/** `<cwd>/.qlogicagent/sessions/{sessionId}` */
+export function getProjectSessionDir(cwd, sessionId) {
+    return join(getProjectSessionsRoot(cwd), sessionId);
+}
+/** `<cwd>/.qlogicagent/checkpoints/` or `<cwd>/.qlogicagent/checkpoints/{sessionId}` */
+export function getProjectCheckpointsDir(cwd, sessionId) {
+    const base = join(getProjectAgentDir(cwd), "checkpoints");
+    return sessionId ? join(base, sessionId) : base;
+}
+// ── Git-root-level paths ────────────────────────────────────
+/** `<gitRoot>/.qlogicagent/hooks/` */
+export function getGitRootHooksDir(gitRoot) {
+    return join(gitRoot, AGENT_DOT_DIR, "hooks");
+}
+// ── Cross-project discovery ─────────────────────────────────
+// (Removed: skills now live in a single global store; per-project applicability
+//  is governed by skills-enabled.json — see project-skill-manifest.ts.)

package/dist/runtime/infra/agent-paths.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/infra/agent-paths.test.js

@@ -0,0 +1,49 @@
+import { describe, expect, it, vi, afterEach } from "vitest";
+import path from "node:path";
+import * as agentPaths from "./agent-paths.js";
+import { getOwnerProfileDir, getProfileMemoryDir, getUserCredentialsPath, getUserInstructionsPath, getUserMarketplaceConfigPath, getUserMcpConfigPath, getUserPluginsDir, getUserRulesDir, getUserSettingsPath, getUserSkillsDir, getUserWorkflowsDir, getUserAgentHome, resolveActiveOwnerUserId, } from "./agent-paths.js";
+afterEach(() => {
+    vi.unstubAllEnvs();
+});
+describe("agent profile paths", () => {
+    it("routes owner-scoped data into a safe profiles/<owner> directory", () => {
+        vi.stubEnv("QLOGICAGENT_HOME", path.join("C:", "tmp", "qlogicagent-home"));
+        expect(getOwnerProfileDir("user/alice")).toBe(path.join(getUserAgentHome(), "profiles", "user%2Falice"));
+        expect(getProfileMemoryDir("user/alice")).toBe(path.join(getUserAgentHome(), "profiles", "user%2Falice", "memory"));
+    });
+    it("routes user-level skills into the active owner profile", () => {
+        vi.stubEnv("QLOGICAGENT_HOME", path.join("C:", "tmp", "qlogicagent-home"));
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        expect(getUserSkillsDir()).toBe(path.join(getUserAgentHome(), "profiles", "user%2Falice", "skills"));
+    });
+    it("routes owner settings into the active owner profile", () => {
+        vi.stubEnv("QLOGICAGENT_HOME", path.join("C:", "tmp", "qlogicagent-home"));
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        expect(getUserSettingsPath()).toBe(path.join(getUserAgentHome(), "profiles", "user%2Falice", "settings.json"));
+    });
+    it("does not expose pre-profile global storage helpers", () => {
+        expect(Object.prototype.hasOwnProperty.call(agentPaths, "getLegacyUserSettingsPath")).toBe(false);
+        expect(Object.prototype.hasOwnProperty.call(agentPaths, "getLegacyMemoryDbPath")).toBe(false);
+    });
+    it("routes owner behavior files into the active owner profile", () => {
+        vi.stubEnv("QLOGICAGENT_HOME", path.join("C:", "tmp", "qlogicagent-home"));
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user/alice");
+        const profile = path.join(getUserAgentHome(), "profiles", "user%2Falice");
+        expect(getUserCredentialsPath()).toBe(path.join(profile, ".credentials.json"));
+        expect(getUserPluginsDir()).toBe(path.join(profile, "plugins"));
+        expect(getUserMcpConfigPath()).toBe(path.join(profile, "mcp.json"));
+        expect(getUserMarketplaceConfigPath()).toBe(path.join(profile, "marketplace.json"));
+        expect(getUserWorkflowsDir()).toBe(path.join(profile, "workflows"));
+        expect(getUserInstructionsPath()).toBe(path.join(profile, "INSTRUCTIONS.md"));
+        expect(getUserRulesDir()).toBe(path.join(profile, "rules"));
+    });
+    it("uses the llmrouter owner first and falls back to an implicit local owner", () => {
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "user-alice");
+        expect(resolveActiveOwnerUserId()).toBe("user-alice");
+        vi.stubEnv("QLOGIC_LLMROUTER_USER_ID", "");
+        vi.stubEnv("QLOGIC_IMPLICIT_OWNER_ID", "oc_device_123");
+        expect(resolveActiveOwnerUserId()).toBe("oc_device_123");
+        vi.stubEnv("QLOGIC_IMPLICIT_OWNER_ID", "");
+        expect(resolveActiveOwnerUserId()).toBe("oc_local");
+    });
+});