@ory/continue 0.10.0

package/dist/handlers.js

@@ -0,0 +1,567 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleHookEvent = handleHookEvent;
+const argus_1 = require("@ory/argus");
+const HARNESS = "continue";
+const BIN_NAME = "ory-continue";
+/**
+ * Route a Continue CLI hook event to the appropriate Ory integration.
+ *
+ * Event names are verified against @continuedev/cli. Unknown events pass
+ * through.
+ */
+async function handleHookEvent(input, client, deps = {}) {
+    const event = input.hook_event_name;
+    client.logger.debug("hook.received", {
+        event,
+        sessionId: input.session_id,
+        toolName: input.tool_name,
+    });
+    // Set trace context so all spans within this hook invocation correlate
+    client.tracer.setContext({
+        traceId: (0, argus_1.deriveTraceId)(input.session_id),
+        sessionId: input.session_id,
+    });
+    try {
+        switch (event) {
+            case "SessionStart":
+                return await handleSessionStart(input, client, deps);
+            case "PreToolUse":
+                return await handlePreToolUse(input, client, deps);
+            case "PostToolUse":
+                return await handlePostToolUse(input, client);
+            case "PostToolUseFailure":
+                return await handlePostToolUseFailure(input, client);
+            case "PermissionRequest":
+                return await handlePermissionRequest(input, client);
+            case "UserPromptSubmit":
+                return await handleUserPromptSubmit(input, client);
+            case "SubagentStart":
+                return await handleSubagentStart(input, client, deps);
+            case "SubagentStop":
+                return await handleSubagentStop(input, client);
+            case "Stop":
+                return await handleStop(input, client);
+            case "SessionEnd":
+                return await handleSessionEnd(input, client);
+            case "PreCompact":
+                return await handlePreCompact(input, client);
+            default:
+                client.logger.debug("hook.passthrough", { event });
+                client.tracer.record("hook.passthrough", "skipped", {
+                    attributes: { event },
+                });
+                return {};
+        }
+    }
+    finally {
+        client.tracer.clearContext();
+    }
+}
+// ─── SessionStart ───────────────────────────────────────────────────
+async function handleSessionStart(input, client, deps) {
+    client.logger.info("lifecycle.session_start", {
+        sessionId: input.session_id,
+        model: input.model,
+        source: input.source,
+        cwd: input.cwd,
+    });
+    client.tracer.record("session.start", "ok", {
+        attributes: { model: input.model, source: input.source },
+    });
+    // Run the user login (interactive PKCE on first session, refresh when
+    // needed). Continue dispatches SessionStart as a subprocess hook that can
+    // hard-block via exit code 2, so allowBlock is true.
+    const userGate = deps.userLogin ?? argus_1.ensureUserAuthenticated;
+    const decision = await userGate(client, {
+        binName: BIN_NAME,
+        harness: HARNESS,
+        allowBlock: true,
+    });
+    // Resolve the agent identity (machine credentials) regardless of how user
+    // auth went — never blocks, attaches the agent's bearer token to outgoing
+    // Ory API calls.
+    const agentGate = deps.agentGate ?? argus_1.ensureAgentIdentity;
+    await agentGate(client, { projectUrl: (0, argus_1.resolveConfig)().projectUrl, harness: HARNESS });
+    // Record the user→agent delegation for the audit trail. Best-effort and
+    // fail-open.
+    await recordUserDelegatesAgent(client);
+    if (!decision.proceed) {
+        return { decision: "block", reason: decision.reason };
+    }
+    if (decision.mode !== "disabled") {
+        return {};
+    }
+    const resolved = (0, argus_1.resolveConfig)();
+    if (resolved.auditOnly) {
+        client.logger.info("config.audit_only", {
+            message: "Audit-only mode enabled. Auth and permission checks are disabled.",
+        });
+        return {};
+    }
+    if (!resolved.projectUrl) {
+        client.logger.warn("config.not_configured", {
+            message: "Ory plugin is not configured. Auth and permission checks are disabled. " +
+                "Run 'npx ory-continue configure' to connect to an Ory project.",
+        });
+        return {};
+    }
+    // Try session token first, then OAuth2 token
+    const sessionToken = process.env.ORY_SESSION_TOKEN;
+    const oauth2Token = process.env.ORY_OAUTH2_TOKEN;
+    if (sessionToken) {
+        await verifySessionToken(sessionToken, client);
+        return {};
+    }
+    if (oauth2Token) {
+        await verifyOAuth2Token(oauth2Token, client);
+        return {};
+    }
+    client.logger.warn("session.no_credentials", {
+        message: "Neither ORY_SESSION_TOKEN nor ORY_OAUTH2_TOKEN is set. " +
+            "Skipping authentication.",
+    });
+    return {};
+}
+async function verifySessionToken(token, client) {
+    try {
+        const session = await client.verifySession(token);
+        if (!session.active) {
+            client.logger.warn("session.inactive", {
+                message: "Ory session is not active. Re-authenticate to enable auth checks.",
+            });
+        }
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("session.verify_failed", {
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+async function verifyOAuth2Token(token, client) {
+    try {
+        const tokenInfo = await client.introspectToken(token);
+        if (!tokenInfo.active) {
+            client.logger.warn("oauth2.token_inactive", {
+                message: "Ory OAuth2 token is not active. Obtain a new token to enable auth checks.",
+            });
+            return;
+        }
+        client.logger.info("oauth2.session_authenticated", {
+            clientId: tokenInfo.clientId,
+            subject: tokenInfo.subject,
+            scope: tokenInfo.scope,
+        });
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("oauth2.introspect_failed", {
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+// ─── PreToolUse ─────────────────────────────────────────────────────
+async function handlePreToolUse(input, client, deps = {}) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.pre_tool_use", {
+        sessionId: input.session_id,
+        toolName,
+        toolInput: input.tool_input,
+    });
+    const inputSummary = (0, argus_1.summarizeToolInput)(toolName, input.tool_input);
+    // If the agent is invoking a sub-agent (a Task/Agent tool call with a
+    // subagent_type), resolve a distinct OAuth2 identity for it and record the
+    // delegation. Best-effort — never blocks the actual tool call.
+    await maybeRegisterSubAgent(toolName, input.tool_input, client, deps);
+    // In audit-only mode, log the invocation but skip permission checks
+    if ((0, argus_1.resolveConfig)().auditOnly) {
+        client.tracer.record("tool.invoke", "ok", {
+            attributes: { toolName, ...inputSummary },
+        });
+        return {};
+    }
+    const subject = (0, argus_1.resolveUserSubject)(client, `session:${input.session_id}`);
+    const subjectId = (0, argus_1.subjectLabel)(subject);
+    const namespace = resolveNamespace();
+    try {
+        // No Continue-specific MCP tool parser exists in core, so gate every tool
+        // by name. MCP tools (if Continue namespaces them) flow through the same
+        // path keyed on the tool name.
+        const outcome = await (0, argus_1.gateToolCall)(client, {
+            harness: HARNESS,
+            toolName,
+            check: { namespace, object: toolName, relation: "use", ...subject },
+            spanAttributes: { toolName },
+        });
+        // Interactive tools surface UI to the user and aren't external-system tool
+        // executions. gateToolCall has already recorded the `user.interaction`
+        // audit span; pass through with no tool.invoke/tool.block.
+        if (outcome.kind === "interactive") {
+            return {};
+        }
+        const decision = outcome;
+        if (decision.kind === "fail_open") {
+            return handlePermissionError(decision.error, toolName, client);
+        }
+        const attrs = { toolName, ...inputSummary };
+        const decisionAttrs = decision.spanAttributes;
+        if (decision.kind === "allow") {
+            client.tracer.record("tool.invoke", "ok", {
+                attributes: { ...attrs, ...decisionAttrs, allowed: true },
+            });
+            return {};
+        }
+        if (decision.kind === "observe") {
+            client.tracer.record("tool.block", "denied", {
+                attributes: { ...attrs, ...decisionAttrs, allowed: false, ...(0, argus_1.alertAttributes)(false) },
+            });
+            client.tracer.record("tool.invoke", "ok", {
+                attributes: { ...attrs, ...decisionAttrs, allowed: false, observed: true },
+            });
+            return {};
+        }
+        // deny
+        client.tracer.record("tool.block", "denied", {
+            attributes: { ...attrs, ...decisionAttrs, allowed: false, ...(0, argus_1.alertAttributes)(true) },
+        });
+        const reason = (0, argus_1.formatDenialMessage)({ tool: toolName, subjectId, namespace });
+        return {
+            decision: "block",
+            reason,
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: "deny",
+                permissionDecisionReason: reason,
+            },
+        };
+    }
+    catch (err) {
+        return handlePermissionError(err, toolName, client);
+    }
+}
+// ─── PostToolUse ────────────────────────────────────────────────────
+async function handlePostToolUse(input, client) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.post_tool_use", {
+        sessionId: input.session_id,
+        toolName,
+        toolResponse: input.tool_response,
+    });
+    client.tracer.record("tool.complete", "ok", {
+        attributes: {
+            toolName,
+            toolUseId: input.tool_use_id,
+            ...(0, argus_1.summarizeToolInput)(toolName, input.tool_input),
+            ...(0, argus_1.summarizeToolOutput)(toolName, input.tool_response),
+        },
+    });
+    return {};
+}
+// ─── PostToolUseFailure ─────────────────────────────────────────────
+async function handlePostToolUseFailure(input, client) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.post_tool_use_failure", {
+        sessionId: input.session_id,
+        toolName,
+        toolUseId: input.tool_use_id,
+    });
+    client.tracer.record("tool.fail", "error", {
+        attributes: {
+            toolName,
+            toolUseId: input.tool_use_id,
+            toolError: typeof input.error === "string"
+                ? input.error.slice(0, 500)
+                : undefined,
+            ...(0, argus_1.summarizeToolInput)(toolName, input.tool_input),
+        },
+    });
+    return {};
+}
+// ─── UserPromptSubmit ──────────────────────────────────────────────
+async function handleUserPromptSubmit(input, client) {
+    client.logger.info("lifecycle.user_prompt_submit", {
+        sessionId: input.session_id,
+        promptLen: input.prompt?.length,
+    });
+    client.tracer.record("user.prompt", "ok", {
+        attributes: { promptLen: input.prompt?.length },
+    });
+    return {};
+}
+// ─── SubagentStart ─────────────────────────────────────────────────
+async function handleSubagentStart(input, client, deps) {
+    const subAgentType = input.subagent_type ?? input.agent_type;
+    const agentId = input.agent_id;
+    client.logger.info("lifecycle.subagent_start", {
+        sessionId: input.session_id,
+        subAgentType,
+        agentId,
+    });
+    client.tracer.record("subagent.start", "ok", {
+        attributes: { subAgentType, agentId },
+    });
+    if (subAgentType) {
+        await registerSubAgent(subAgentType, client, deps);
+    }
+    else {
+        client.logger.debug("subagent_start.no_type", {
+            message: "SubagentStart event without subagent_type — skipping DCR.",
+        });
+    }
+    return {};
+}
+// ─── SubagentStop ──────────────────────────────────────────────────
+async function handleSubagentStop(input, client) {
+    client.logger.info("lifecycle.subagent_stop", {
+        sessionId: input.session_id,
+        subAgentType: input.subagent_type ?? input.agent_type,
+        agentId: input.agent_id,
+    });
+    client.tracer.record("subagent.stop", "ok", {
+        attributes: {
+            subAgentType: input.subagent_type ?? input.agent_type,
+            agentId: input.agent_id,
+            responseLen: input.subagent_response?.length,
+        },
+    });
+    return {};
+}
+// ─── Stop ──────────────────────────────────────────────────────────
+async function handleStop(input, client) {
+    client.logger.info("lifecycle.stop", {
+        sessionId: input.session_id,
+    });
+    client.tracer.record("turn.stop", "ok", {
+        attributes: { responseLen: input.last_assistant_message?.length },
+    });
+    return {};
+}
+// ─── SessionEnd ────────────────────────────────────────────────────
+async function handleSessionEnd(input, client) {
+    client.logger.info("lifecycle.session_end", {
+        sessionId: input.session_id,
+        reason: input.reason,
+    });
+    client.tracer.record("session.end", "ok", {
+        attributes: { reason: input.reason },
+    });
+    return {};
+}
+// ─── PreCompact ────────────────────────────────────────────────────
+async function handlePreCompact(input, client) {
+    client.logger.info("lifecycle.pre_compact", {
+        sessionId: input.session_id,
+        trigger: input.trigger,
+    });
+    client.tracer.record("compaction", "ok", {
+        attributes: { trigger: input.trigger, stage: "pre_compact" },
+    });
+    return {};
+}
+// ─── PermissionRequest ──────────────────────────────────────────────
+//
+// Continue surfaces a structured permission decision via
+// hookSpecificOutput.decision.{behavior}. Omitting `decision` falls through to
+// Continue's normal user prompt. This event is trace-only on the auth side: it
+// records the audit span and answers allow/deny based on policy, but never
+// hard-blocks the session (the answer is advisory to the user prompt).
+async function handlePermissionRequest(input, client) {
+    const toolName = input.tool_name ?? "unknown";
+    client.logger.info("lifecycle.permission_request", {
+        sessionId: input.session_id,
+        toolName,
+        toolInput: input.tool_input,
+    });
+    // Audit-only mode: omit `decision` so Continue falls through to its normal
+    // user-permission prompt.
+    if ((0, argus_1.resolveConfig)().auditOnly) {
+        return permissionRequestFallback("Audit-only mode — deferring to user");
+    }
+    // Interactive tools: the harness is about to surface UI to the user. Trace
+    // and fall through — Ory shouldn't pre-answer a prompt meant for the human.
+    if ((0, argus_1.isInteractiveTool)(HARNESS, toolName)) {
+        client.tracer.record("user.interaction", "ok", {
+            attributes: { harness: HARNESS, toolName, kind: "permission-request" },
+        });
+        return permissionRequestFallback("Interactive tool — deferring to user");
+    }
+    const subject = (0, argus_1.resolveUserSubject)(client, `session:${input.session_id}`);
+    const subjectId = (0, argus_1.subjectLabel)(subject);
+    const namespace = resolveNamespace();
+    try {
+        const outcome = await (0, argus_1.gateToolCall)(client, {
+            harness: HARNESS,
+            toolName,
+            check: { namespace, object: toolName, relation: "use", ...subject },
+            spanAttributes: { toolName },
+        });
+        if (outcome.kind === "interactive") {
+            return permissionRequestFallback("Interactive tool — deferring to user");
+        }
+        const decision = outcome;
+        if (decision.kind === "fail_open") {
+            const code = decision.error.code;
+            const fallbackReason = code === "network_error" || code === "rate_limited"
+                ? `Ory unavailable (${code}), falling back to user prompt`
+                : `Ory permission check failed: ${decision.error.message}`;
+            return permissionRequestFallback(fallbackReason);
+        }
+        if (decision.kind === "deny") {
+            return permissionRequestDecision("deny", (0, argus_1.formatDenialMessage)({ tool: toolName, subjectId, namespace }));
+        }
+        return permissionRequestDecision("allow", decision.kind === "observe"
+            ? "Ory observe mode — denied by policy but allowed through"
+            : "Ory permission granted");
+    }
+    catch (err) {
+        const oryErr = err;
+        const fallbackReason = oryErr.code === "network_error" || oryErr.code === "rate_limited"
+            ? `Ory unavailable (${oryErr.code}), falling back to user prompt`
+            : `Ory permission check failed: ${oryErr.message}`;
+        return permissionRequestFallback(fallbackReason);
+    }
+}
+function permissionRequestDecision(behavior, reason) {
+    return {
+        hookSpecificOutput: {
+            hookEventName: "PermissionRequest",
+            decision: { behavior },
+            message: reason,
+        },
+    };
+}
+function permissionRequestFallback(reason) {
+    return {
+        hookSpecificOutput: {
+            hookEventName: "PermissionRequest",
+            message: reason,
+        },
+    };
+}
+// ─── Helpers ────────────────────────────────────────────────────────
+function resolveNamespace() {
+    return process.env.ORY_PERMISSION_NAMESPACE ?? "AgentTools";
+}
+/**
+ * Write the user→agent delegation tuple. Idempotent and fail-open: requires
+ * both principal subjects to be populated; any error is logged and swallowed.
+ */
+async function recordUserDelegatesAgent(client) {
+    const user = client.userPrincipal.subject;
+    const agent = client.agentPrincipal.subject;
+    if (!user || !agent) {
+        client.logger.debug("delegation.skip", {
+            reason: "missing principal",
+            hasUser: !!user,
+            hasAgent: !!agent,
+        });
+        return;
+    }
+    try {
+        await client.createRelationship({
+            namespace: resolveNamespace(),
+            object: `agent:${agent}`,
+            relation: "delegate",
+            subjectId: `user:${user}`,
+        }, { spanAttributes: { delegation: "user-to-agent" } });
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("delegation.user_to_agent.failed", {
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+/**
+ * Register an OAuth2 identity for a sub-agent and write the
+ * `agent → subagent` delegation tuple. Fail-open and idempotent.
+ */
+async function registerSubAgent(subAgentType, client, deps) {
+    const subAgentGate = deps.subAgentGate ?? argus_1.ensureSubAgentIdentity;
+    let identity;
+    try {
+        identity = await subAgentGate(client, {
+            subAgentType,
+            projectUrl: (0, argus_1.resolveConfig)().projectUrl,
+            harness: HARNESS,
+        });
+    }
+    catch (err) {
+        client.logger.warn("subagent.identity.failed", {
+            subAgentType,
+            message: err instanceof Error ? err.message : String(err),
+        });
+        return;
+    }
+    if (identity.kind !== "dynamic" || !identity.subject)
+        return;
+    const agent = client.agentPrincipal.subject;
+    if (!agent) {
+        client.logger.debug("delegation.skip", {
+            reason: "agent principal not populated",
+            subAgentType,
+        });
+        return;
+    }
+    try {
+        await client.createRelationship({
+            namespace: resolveNamespace(),
+            object: `subagent:${identity.subject}`,
+            relation: "delegate",
+            subjectId: `agent:${agent}`,
+        }, { spanAttributes: { delegation: "agent-to-subagent", subAgentType } });
+    }
+    catch (err) {
+        const oryErr = err;
+        client.logger.warn("delegation.agent_to_subagent.failed", {
+            subAgentType,
+            code: oryErr.code,
+            message: oryErr.message,
+        });
+    }
+}
+/**
+ * Fallback for the case where a sub-agent invocation appears as a Task/Agent
+ * tool call in PreToolUse with a `subagent_type` field on tool_input.
+ * registerSubAgent is idempotent so running both this and the dedicated
+ * SubagentStart path is harmless.
+ */
+async function maybeRegisterSubAgent(toolName, toolInput, client, deps) {
+    if (toolName !== "Task" && toolName !== "Agent")
+        return;
+    const subAgentType = typeof toolInput === "object"
+        && toolInput !== null
+        && typeof toolInput.subagent_type === "string"
+        ? toolInput.subagent_type
+        : undefined;
+    if (!subAgentType)
+        return;
+    await registerSubAgent(subAgentType, client, deps);
+}
+function handlePermissionError(oryErr, toolName, client) {
+    if (oryErr.code === "network_error") {
+        client.logger.warn("permission.network_error", {
+            toolName,
+            message: "Ory unreachable, failing open",
+        });
+        return {};
+    }
+    if (oryErr.code === "rate_limited") {
+        client.logger.warn("permission.rate_limited", {
+            toolName,
+            message: "Ory rate limited, failing open",
+        });
+        return {};
+    }
+    // For other errors, also fail open but log prominently
+    client.logger.error("permission.check.error", {
+        toolName,
+        code: oryErr.code,
+        message: oryErr.message,
+    });
+    return {};
+}

package/dist/hook.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * Continue CLI (`cn`) hook entry point.
+ * This script is invoked by Continue for each hook event.
+ * Input: JSON on stdin
+ * Output: JSON on stdout
+ * Exit code 2 = block the action
+ *
+ * Verified against @continuedev/cli: `cn` dispatches command hooks as
+ * subprocesses with JSON on stdin/stdout and treats exit code 2 as a hard
+ * block (Claude-Code-compatible).
+ */
+export {};

package/dist/hook.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Continue CLI (`cn`) hook entry point.
+ * This script is invoked by Continue for each hook event.
+ * Input: JSON on stdin
+ * Output: JSON on stdout
+ * Exit code 2 = block the action
+ *
+ * Verified against @continuedev/cli: `cn` dispatches command hooks as
+ * subprocesses with JSON on stdin/stdout and treats exit code 2 as a hard
+ * block (Claude-Code-compatible).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const argus_1 = require("@ory/argus");
+const handlers_js_1 = require("./handlers.js");
+/**
+ * Read all of stdin as a string.
+ *
+ * Uses event listeners instead of `for await` so that we don't depend on the
+ * parent process closing stdin (sending EOF). If no EOF arrives, we resolve
+ * after a short idle gap once data has been received.
+ */
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let resolved = false;
+        function done() {
+            if (!resolved) {
+                resolved = true;
+                resolve(Buffer.concat(chunks).toString("utf-8"));
+            }
+        }
+        process.stdin.on("data", (chunk) => {
+            chunks.push(chunk);
+            clearTimeout(idleTimer);
+            idleTimer = setTimeout(done, 100);
+        });
+        process.stdin.on("end", done);
+        process.stdin.on("error", (err) => {
+            if (!resolved) {
+                resolved = true;
+                reject(err);
+            }
+        });
+        let idleTimer;
+    });
+}
+async function main() {
+    const client = argus_1.OryAgentClient.fromEnv("continue");
+    const raw = await readStdin();
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch {
+        client.logger.error("hook.stdin.parse_failed", { raw: raw.slice(0, 200) });
+        await client.tracer.shutdown();
+        process.exit(0); // Don't block on parse errors
+    }
+    const output = await (0, handlers_js_1.handleHookEvent)(input, client);
+    if (output.decision === "block") {
+        process.stdout.write(JSON.stringify(output));
+        await client.tracer.shutdown();
+        process.exit(2);
+    }
+    if (output.hookSpecificOutput || output.systemMessage) {
+        process.stdout.write(JSON.stringify(output));
+    }
+    await client.tracer.shutdown();
+    process.exit(0);
+}
+main().catch((err) => {
+    process.stderr.write(`[ory-agent] fatal: ${err}\n`);
+    process.exit(0); // Fail open
+});

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { handleHookEvent } from "./handlers.js";
+export type { HandleHookEventDeps } from "./handlers.js";
+export { generateSettings, generateInstalledSettings, generateDevSettings, } from "./settings.js";
+export type { ContinueHookInput, ContinueHookOutput } from "./types.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDevSettings = exports.generateInstalledSettings = exports.generateSettings = exports.handleHookEvent = void 0;
+var handlers_js_1 = require("./handlers.js");
+Object.defineProperty(exports, "handleHookEvent", { enumerable: true, get: function () { return handlers_js_1.handleHookEvent; } });
+var settings_js_1 = require("./settings.js");
+Object.defineProperty(exports, "generateSettings", { enumerable: true, get: function () { return settings_js_1.generateSettings; } });
+Object.defineProperty(exports, "generateInstalledSettings", { enumerable: true, get: function () { return settings_js_1.generateInstalledSettings; } });
+Object.defineProperty(exports, "generateDevSettings", { enumerable: true, get: function () { return settings_js_1.generateDevSettings; } });

package/dist/settings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Generate the .continue/settings.json hooks section that configures Ory hooks.
+ *
+ * Continue's hook block is Claude-Code-compatible: a top-level `hooks` object
+ * mapping each event name to an array of matcher entries, each carrying
+ * command-type hooks. Verified against @continuedev/cli.
+ */
+export declare function generateSettings(hookScriptPath: string): object;
+/**
+ * Generate settings assuming the plugin is installed via npm/pnpm.
+ */
+export declare function generateInstalledSettings(): object;
+/**
+ * Generate settings pointing to a local dev build.
+ */
+export declare function generateDevSettings(packageDir: string): object;