@lore-co/cli 0.2.4 → 0.2.7

package/dist/runtime.js

@@ -6,12 +6,13 @@ import { dirname, parse, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { promisify } from "node:util";
-import { boundedUtf8Text, repositoryScopeFromGitRoot, } from "./repository.js";
+import { boundedUtf8Text, repositoryScopeFromGitRoot, repositoryScopeFromDirectory, } from "./repository.js";
 import { ReliabilityStore, ReliabilityStoreError, atomicWriteJson as durableAtomicWriteJson, classifyRetryFailure, createIntegrationInvocationAttempt, durableUnlink, recordLocalGuardMetric, recordLocalRetrievalMetric, } from "./reliability-store.js";
 import { writeInvocationAttemptBounded, writeInvocationCompletionBounded, } from "./invocation-health-writer.js";
 import { SignedSnapshotError, verifySignedSnapshot, } from "./signed-snapshot.js";
 import { CONTEXT_CACHE_MAX_STALE_MS, isContextTransportFailure, selectCachedContext, } from "./context-fallback.js";
 import { RUNTIME_VERSION } from "./runtime-version.js";
+import { checkLoreAccess, checkDirectory, checkWorkspaceRepository, readLocalConfig, resolveLocalConnection, bindLocalSession } from "./directory-policy.js";
 import { capturePendingImages, enqueueEventImages, flushImageAttachment, hostMessageImages, rememberImageCapture } from "./image-capture.js";
 import { guardRuleConflict, guardToolTrigger, supportedGuardRule, guardEmergencyCommand, emergencyOverrideApplies } from "@lore-co/core/guard-evaluation";
 const IS_STANDALONE_RUNTIME = typeof __LORE_STANDALONE__ === "boolean" && __LORE_STANDALONE__;
@@ -367,9 +368,11 @@ async function atomicWriteJson(path, value) {
     await chmod(dirname(path), 0o700);
     await durableAtomicWriteJson(path, value);
 }
-async function readRuntimeConfig(home) {
+async function readRuntimeConfig(home, cwd) {
+    const saved = await readLocalConfig(home);
+    const selected = saved?.savedConnections && cwd !== undefined ? await resolveLocalConnection(cwd, home) : saved;
     try {
-        const parsed = JSON.parse(await readFile(resolve(loreDirectory(home), "config.json"), "utf8"));
+        const parsed = selected;
         if (!isObject(parsed) ||
             (parsed.version !== 1 && parsed.version !== 2) ||
             typeof parsed.apiUrl !== "string" ||
@@ -394,6 +397,7 @@ async function readRuntimeConfig(home) {
             : undefined;
         return {
             version: parsed.version,
+            ...(typeof parsed.connectionId === "string" ? { connectionId: parsed.connectionId } : {}),
             apiUrl: parsed.apiUrl,
             ...(dashboardUrl === undefined ? {} : { dashboardUrl }),
             ...(workspaceId === undefined ? {} : { workspaceId }),
@@ -406,17 +410,17 @@ async function readRuntimeConfig(home) {
         return null;
     }
 }
-function pendingPath(agent, sessionId, home) {
-    return resolve(loreDirectory(home), "state", "pending", `${sha256(`${agent}\0${sessionId}`)}.json`);
+function pendingPath(agent, sessionId, home, connectionId) {
+    return resolve(loreDirectory(home), "state", "pending", `${sha256(`${connectionId ? `${connectionId}\0` : ""}${agent}\0${sessionId}`)}.json`);
 }
-async function savePending(input, agent, sessionId, now, home) {
+async function savePending(input, agent, sessionId, now, home, connectionId) {
     const assistantMessage = stringField(input.last_assistant_message);
     if (assistantMessage === undefined) {
         return;
     }
     const cwd = stringField(input.cwd);
     const turnId = stringField(input.turn_id);
-    await atomicWriteJson(pendingPath(agent, sessionId, home), {
+    await atomicWriteJson(pendingPath(agent, sessionId, home, connectionId), {
         agent,
         sessionId,
         assistantMessage: redactSecrets(assistantMessage),
@@ -425,8 +429,8 @@ async function savePending(input, agent, sessionId, now, home) {
         capturedAt: now.toISOString(),
     });
 }
-async function readPending(agent, sessionId, home) {
-    const path = pendingPath(agent, sessionId, home);
+async function readPending(agent, sessionId, home, connectionId) {
+    const path = pendingPath(agent, sessionId, home, connectionId);
     try {
         const parsed = JSON.parse(await readFile(path, "utf8"));
         if (!isObject(parsed) ||
@@ -456,8 +460,8 @@ async function readPending(agent, sessionId, home) {
         return null;
     }
 }
-async function clearPending(agent, sessionId, home) {
-    await durableUnlink(pendingPath(agent, sessionId, home), true);
+async function clearPending(agent, sessionId, home, connectionId) {
+    await durableUnlink(pendingPath(agent, sessionId, home, connectionId), true);
 }
 function normalizedRepositoryPath(value) {
     const parts = [];
@@ -983,10 +987,12 @@ function runtimeAccept(config) {
 async function runtimeStore(config, home) {
     const store = new ReliabilityStore(reliabilityWorkspaceKey(config), {
         home: homeDirectory(home),
+        ...(config.connectionId ? { connectionId: config.connectionId } : {}),
     });
     await store.initialize();
-    await store.migrateLegacyQueue(queueDirectory(home));
-    if (config.workspaceId !== undefined) {
+    if (!config.connectionId)
+        await store.migrateLegacyQueue(queueDirectory(home));
+    if (config.workspaceId !== undefined && !config.connectionId) {
         const credentialStore = new ReliabilityStore(credentialReliabilityWorkspaceKey(config), { home: homeDirectory(home) });
         await credentialStore.transferPendingTo(store).catch(() => undefined);
     }
@@ -1511,6 +1517,7 @@ async function flushOne(config, fetchImplementation, store) {
     const claimed = await store.claimNext({
         workerId: `native-hook:${process.pid}`,
         kinds: ["turn", "prompt", "guard_override"],
+        eligible: async (entry) => entry.kind === "guard_override" || (await checkWorkspaceRepository(config, queuedRequest(entry.payload)?.request.scope?.repo, fetchImplementation)).allowed,
     });
     if (claimed === null || claimed.claim === undefined) {
         return null;
@@ -1541,6 +1548,9 @@ async function flushOne(config, fetchImplementation, store) {
                 state: failed.state === "auth-blocked" ? "auth-blocked" : "dead",
             };
         }
+        const permission = await checkWorkspaceRepository(config, queued.request.scope?.repo, fetchImplementation);
+        if (!permission.allowed)
+            throw Object.assign(new Error(permission.reason), { retryable: true });
         let delivery;
         if (queued.kind === "turn") {
             delivery = await postTurn(config, queued.request, fetchImplementation, store);
@@ -1631,12 +1641,12 @@ const GUARD_SHELL_TOOLS = new Set(["Bash", "bash", "Shell", "shell", "exec_comma
 export function guardTrigger(toolName, toolInput) {
     return guardToolTrigger(toolName, toolInput);
 }
-function guardStatePath(agent, sessionId, home) {
-    return resolve(loreDirectory(home), "state", "guard", `${sha256(`${agent}\0${sessionId}`)}.json`);
+function guardStatePath(agent, sessionId, home, connectionId) {
+    return resolve(loreDirectory(home), "state", "guard", `${sha256(`${connectionId ? `${connectionId}\0` : ""}${agent}\0${sessionId}`)}.json`);
 }
-async function readGuardState(agent, sessionId, home) {
+async function readGuardState(agent, sessionId, home, connectionId) {
     try {
-        const parsed = JSON.parse(await readFile(guardStatePath(agent, sessionId, home), "utf8"));
+        const parsed = JSON.parse(await readFile(guardStatePath(agent, sessionId, home, connectionId), "utf8"));
         if (isObject(parsed)) {
             return {
                 ...(typeof parsed.mode === "string" ? { mode: parsed.mode } : {}),
@@ -1654,12 +1664,12 @@ async function readGuardState(agent, sessionId, home) {
     }
     return { keys: {} };
 }
-async function writeGuardState(agent, sessionId, state, home) {
+async function writeGuardState(agent, sessionId, state, home, connectionId) {
     const entries = Object.entries(state.keys)
         .sort((a, b) => (a[1] < b[1] ? 1 : -1))
         .slice(0, GUARD_MAX_CACHED_KEYS);
     try {
-        await atomicWriteJson(guardStatePath(agent, sessionId, home), {
+        await atomicWriteJson(guardStatePath(agent, sessionId, home, connectionId), {
             ...state,
             keys: Object.fromEntries(entries),
         });
@@ -1890,7 +1900,7 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now) {
         return undefined;
     }
     const store = await runtimeStore(config, options.home);
-    const state = await readGuardState(agent, sessionId, options.home);
+    const state = await readGuardState(agent, sessionId, options.home, config.connectionId);
     const rememberedPolicy = await store.readState("guard-policy-state");
     const enforcementMayHaveChanged = isObject(rememberedPolicy) && (rememberedPolicy.mode === "enforce" ||
         (Array.isArray(rememberedPolicy.overrides) && rememberedPolicy.overrides.some((entry) => isObject(entry) && entry.mode === "enforce")));
@@ -1971,7 +1981,7 @@ async function handleGuardEvent(input, agent, config, sessionId, options, now) {
     if (!result.requiresConfirmation && !result.policyUnavailable) {
         state.keys[key] = now.toISOString();
     }
-    await writeGuardState(agent, sessionId, state, options.home).catch(() => undefined);
+    await writeGuardState(agent, sessionId, state, options.home, config.connectionId).catch(() => undefined);
     if (result.mode === "off") {
         return undefined;
     }
@@ -2040,10 +2050,45 @@ export async function handleHookEvent(value, agent, options = {}) {
         !validHookInput(input, agent, eventName)) {
         throw new InvalidHookInputError();
     }
-    const config = await readRuntimeConfig(options.home);
+    let config;
+    try {
+        config = await readRuntimeConfig(options.home, stringField(input.cwd) ?? "");
+    }
+    catch (error) {
+        if (eventName !== "UserPromptSubmit" && eventName !== "SessionStart")
+            return undefined;
+        const notice = `Lore is off: ${error instanceof Error ? error.message : "connection unavailable"}`;
+        return agent === "cursor" ? { continue: true, userMessage: notice } : agent === "polytoken" ? { outcome: "accept", additional_context: notice } : { systemMessage: notice };
+    }
     if (config === null || !config.agents.includes(agent)) {
         return undefined;
     }
+    if (!await bindLocalSession(homeDirectory(options.home), agent, sessionId, config.connectionId)) {
+        const notice = "Lore is paused for this conversation because its account or workspace changed. Start a new agent session.";
+        return eventName === "UserPromptSubmit" ? (agent === "cursor" ? { continue: true, userMessage: notice } : { systemMessage: notice }) : undefined;
+    }
+    const access = await checkLoreAccess(stringField(input.cwd), options.home, config, options.fetch ?? globalThis.fetch);
+    if (!access.allowed) {
+        await clearPending(agent, sessionId, options.home, config.connectionId);
+        // A policy outage must not silently bypass an already enforced Guard.
+        if (eventName === "PreToolUse" && access.reason === "Workspace repository settings are unavailable") {
+            const prior = await readGuardState(agent, sessionId, options.home, config.connectionId).catch(() => null);
+            const saved = await runtimeStore(config, options.home).then(store => store.readState("guard-policy-state")).catch(() => null);
+            const repo = stringField(input.cwd) ? await repositoryScopeFromDirectory(stringField(input.cwd)) : undefined;
+            const override = isObject(saved) && Array.isArray(saved.overrides) ? saved.overrides.find(value => isObject(value) && value.repo === repo) : undefined;
+            if (prior?.mode === "enforce" || (isObject(override) ? override.mode : isObject(saved) ? saved.mode : undefined) === "enforce") {
+                const reason = "Lore cannot verify workspace repository settings. Restore the connection before retrying.";
+                if (agent === "cursor")
+                    return { permission: "deny", userMessage: reason, agentMessage: reason };
+                if (agent === "copilot-cli")
+                    return { permissionDecision: "deny", permissionDecisionReason: reason };
+                if (agent === "polytoken")
+                    return { outcome: "deny", reason };
+                return { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } };
+            }
+        }
+        return agent === "cursor" && eventName === "UserPromptSubmit" ? { continue: true } : undefined;
+    }
     const now = (options.now ?? (() => new Date()))();
     if (agent === "cursor" && eventName === "SessionStart") {
         const cwd = stringField(input.cwd);
@@ -2060,7 +2105,7 @@ export async function handleHookEvent(value, agent, options = {}) {
             ].join("\n") };
     }
     if (eventName === "Stop" || eventName === "AssistantResponse") {
-        await savePending(input, agent, sessionId, now, options.home);
+        await savePending(input, agent, sessionId, now, options.home, config.connectionId);
         {
             const store = await runtimeStore(config, options.home);
             const codexHome = (options.environment ?? process.env).CODEX_HOME ?? resolve(homeDirectory(options.home), ".codex");
@@ -2069,7 +2114,7 @@ export async function handleHookEvent(value, agent, options = {}) {
             const target = await store.readState(`image-event-${agent}-${sha256(sessionId)}`);
             if (isObject(target) && typeof target.eventId === "string") {
                 await hostMessageImages(input.attachments ?? input.parts ?? input.content, "assistant")
-                    .then(images => enqueueEventImages(store, { connector: "lore-cli", eventId: String(target.eventId), sessionId }, images)).catch(() => undefined);
+                    .then(images => enqueueEventImages(store, { connector: "lore-cli", eventId: String(target.eventId), sessionId, cwd: stringField(target.cwd) }, images)).catch(() => undefined);
             }
             await flushImageAttachment(store, config, options.fetch ?? globalThis.fetch).catch(() => undefined);
         }
@@ -2086,7 +2131,7 @@ export async function handleHookEvent(value, agent, options = {}) {
             return await handleGuardEvent(input, agent, config, sessionId, options, now);
         }
         catch {
-            const prior = await readGuardState(agent, sessionId, options.home).catch(() => null);
+            const prior = await readGuardState(agent, sessionId, options.home, config.connectionId).catch(() => null);
             const saved = await runtimeStore(config, options.home).then((store) => store.readState("guard-policy-state")).catch(() => null);
             const scope = await repositoryScope(stringField(input.cwd)).catch(() => undefined);
             const override = isObject(saved) && Array.isArray(saved.overrides) ? saved.overrides.find((entry) => isObject(entry) && entry.repo === scope?.repo) : undefined;
@@ -2142,7 +2187,16 @@ function cursorSessionKey(sessionId) {
 }
 /** MCP requests are bound to a session/workspace observed by the native hook. */
 async function cursorSession(sessionId, options) {
-    const config = await readRuntimeConfig(options.home);
+    const bindingPath = resolve(loreDirectory(options.home), "state", "connection-sessions", `${sha256(`cursor\0${sessionId}`)}.json`);
+    const binding = await readFile(bindingPath, "utf8").then(value => JSON.parse(value)).catch(() => undefined);
+    let config = await readRuntimeConfig(options.home);
+    if (binding?.connectionId) {
+        const connections = await import("./directory-policy.js").then(module => module.savedLocalConnections(options.home));
+        const saved = connections.find(value => value.connectionId === binding.connectionId);
+        if (!saved)
+            throw new Error("This Cursor connection is no longer available. Start a new conversation.");
+        config = { ...saved, version: 2, agents: Array.isArray(saved.agents) ? saved.agents.filter(isCommandHookAgent) : [] };
+    }
     if (!config?.agents.includes("cursor"))
         throw new Error("Reconnect Cursor to Lore before requesting context.");
     const store = await runtimeStore(config, options.home);
@@ -2150,6 +2204,9 @@ async function cursorSession(sessionId, options) {
     if (!isObject(state) || state.sessionId !== sessionId || !stringField(state.cwd)) {
         throw new Error("Start a new Cursor conversation to register this Lore session.");
     }
+    const access = await checkLoreAccess(stringField(state.cwd), options.home, config, options.fetch ?? globalThis.fetch);
+    if (!access.allowed)
+        throw new Error(`Lore is off: ${access.reason}.`);
     return { config, store, state, cwd: stringField(state.cwd) };
 }
 export async function getCursorContext(sessionId, prompt, options = {}) {
@@ -2162,9 +2219,9 @@ export async function getCursorContext(sessionId, prompt, options = {}) {
     return result?.additional_context || "No relevant shared knowledge was found for this request.";
 }
 export async function completeCursorResponse(sessionId, response, options = {}) {
-    const { store, state, cwd } = await cursorSession(sessionId, options);
+    const { config, store, state, cwd } = await cursorSession(sessionId, options);
     const now = (options.now ?? (() => new Date()))();
-    await savePending({ cwd, last_assistant_message: response }, "cursor", sessionId, now, options.home);
+    await savePending({ cwd, last_assistant_message: response }, "cursor", sessionId, now, options.home, config.connectionId);
     const { prompt: _prompt, promptId: _promptId, ...rest } = state;
     await store.writeState(cursorSessionKey(sessionId), { ...rest, updatedAt: now.toISOString() });
 }
@@ -2210,18 +2267,23 @@ async function handlePromptEvent(input, agent, sessionId, config, options, now,
     catch {
         notices.push("Lore retained queued captures locally, but replay could not run. Run lore doctor.");
     }
-    const pending = capture ? await readPending(agent, sessionId, options.home) : null;
+    let pending = capture ? await readPending(agent, sessionId, options.home, config.connectionId) : null;
+    if (pending && (!(await checkDirectory(pending.cwd, options.home)).allowed ||
+        (pending.cwd !== undefined && pending.cwd !== stringField(input.cwd)))) {
+        await clearPending(agent, sessionId, options.home, config.connectionId);
+        pending = null;
+    }
     const codexHome = (options.environment ?? process.env).CODEX_HOME ?? resolve(homeDirectory(options.home), ".codex");
     const claudeHome = (options.environment ?? process.env).CLAUDE_CONFIG_DIR ?? resolve(homeDirectory(options.home), ".claude");
     await capturePendingImages(store, sessionId, codexHome, claudeHome).catch(() => undefined);
     const rememberImages = async (eventId) => {
         if (!capture)
             return;
-        await store.writeState(`image-event-${agent}-${sha256(sessionId)}`, { eventId });
-        await enqueueEventImages(store, { connector: "lore-cli", eventId, sessionId }, await hostMessageImages(input.attachments ?? input.parts ?? input.content));
+        await store.writeState(`image-event-${agent}-${sha256(sessionId)}`, { eventId, ...(stringField(input.cwd) ? { cwd: stringField(input.cwd) } : {}) });
+        await enqueueEventImages(store, { connector: "lore-cli", eventId, sessionId, cwd: stringField(input.cwd) }, await hostMessageImages(input.attachments ?? input.parts ?? input.content));
         if (agent !== "codex" && agent !== "claude")
             return;
-        await rememberImageCapture(store, { eventId, sessionId, prompt, occurredAt: now.toISOString(), agent,
+        await rememberImageCapture(store, { eventId, sessionId, prompt, occurredAt: now.toISOString(), agent, cwd: stringField(input.cwd),
             ...(typeof input.transcript_path === "string" ? { transcriptPath: input.transcript_path } : {}),
         });
         await capturePendingImages(store, sessionId, codexHome, claudeHome);
@@ -2239,7 +2301,7 @@ async function handlePromptEvent(input, agent, sessionId, config, options, now,
             await enqueueCapture(store, { kind: "turn", request });
             enqueued = true;
             await rememberImages(request.eventId).catch(() => undefined);
-            await clearPending(agent, sessionId, options.home);
+            await clearPending(agent, sessionId, options.home, config.connectionId);
         }
         catch (error) {
             notices.push(error instanceof ReliabilityStoreError &&
@@ -2440,22 +2502,22 @@ function nativeIntegrationId(agent) {
         ? "preview/copilot-vscode"
         : `native/${agent}`;
 }
-async function beginHookInvocation(agent) {
-    const config = await readRuntimeConfig();
+async function beginHookInvocation(agent, cwd) {
+    const config = await readRuntimeConfig(undefined, cwd);
     if (config === null || !config.agents.includes(agent)) {
         return null;
     }
     const workspaceKey = reliabilityWorkspaceKey(config);
     const home = homeDirectory();
     const attempt = createIntegrationInvocationAttempt(nativeIntegrationId(agent), { runtimeVersion: RUNTIME_VERSION });
-    const recorded = await writeInvocationAttemptBounded(workspaceKey, attempt, { home, standalone: IS_STANDALONE_RUNTIME });
-    return recorded ? { workspaceKey, home, attempt } : null;
+    const recorded = await writeInvocationAttemptBounded(workspaceKey, attempt, { home, standalone: IS_STANDALONE_RUNTIME, ...(config.connectionId ? { connectionId: config.connectionId } : {}) });
+    return recorded ? { workspaceKey, home, attempt, ...(config.connectionId ? { connectionId: config.connectionId } : {}) } : null;
 }
 async function finishHookInvocation(tracker, outcome) {
     if (tracker === null) {
         return;
     }
-    await writeInvocationCompletionBounded(tracker.workspaceKey, tracker.attempt, outcome, { home: tracker.home, standalone: IS_STANDALONE_RUNTIME }).catch(() => false);
+    await writeInvocationCompletionBounded(tracker.workspaceKey, tracker.attempt, outcome, { home: tracker.home, standalone: IS_STANDALONE_RUNTIME, ...(tracker.connectionId ? { connectionId: tracker.connectionId } : {}) }).catch(() => false);
 }
 export async function runHook(args = process.argv.slice(2)) {
     const agent = parseAgent(args);
@@ -2465,12 +2527,15 @@ export async function runHook(args = process.argv.slice(2)) {
     if (agent === null) {
         return;
     }
-    const tracker = await beginHookInvocation(agent).catch(() => null);
+    let tracker = null;
     let input;
     try {
         input = await readStdin();
+        const normalized = isObject(input) ? normalizeHookInput(input, agent, process.env).input : {};
+        tracker = await beginHookInvocation(agent, stringField(normalized.cwd) ?? "").catch(() => null);
     }
     catch {
+        tracker = await beginHookInvocation(agent).catch(() => null);
         await finishHookInvocation(tracker, {
             success: false,
             failureCode: "invalid_input",