@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/claude/models.js

@@ -0,0 +1,141 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getClaudeCustomModelThinkingOptions, getClaudeManifestModels, normalizeClaudeManifestModelId, normalizeClaudeRuntimeModelId as normalizeClaudeManifestRuntimeModelId, } from "./model-manifest.js";
+const CLAUDE_SETTINGS_MODEL_ENV_KEYS = [
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_SMALL_FAST_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+];
+export function getClaudeModels(claudeCodeVersion) {
+    return getClaudeManifestModels(claudeCodeVersion);
+}
+export function resolveConfiguredClaudeModel(model) {
+    if (model.thinkingOptions !== undefined)
+        return model;
+    const manifestModelId = normalizeClaudeManifestModelId(model.id);
+    const manifestModel = manifestModelId
+        ? getClaudeModels().find((candidate) => candidate.id === manifestModelId)
+        : undefined;
+    if (manifestModel) {
+        return manifestModel.thinkingOptions
+            ? { ...model, thinkingOptions: manifestModel.thinkingOptions }
+            : model;
+    }
+    return { ...model, thinkingOptions: getClaudeCustomModelThinkingOptions() };
+}
+export function findClaudeModel(modelId) {
+    const normalizedModelId = normalizeClaudeRuntimeModelId(modelId);
+    if (!normalizedModelId) {
+        return undefined;
+    }
+    return getClaudeModels().find((model) => model.id === normalizedModelId);
+}
+export async function getClaudeModelsWithSettings(logger, configDir, claudeCodeVersion) {
+    const hardcodedModels = getClaudeModels(claudeCodeVersion);
+    const settingsModels = await readClaudeSettingsModels(logger, configDir);
+    if (settingsModels.length === 0) {
+        return hardcodedModels;
+    }
+    const models = [...hardcodedModels];
+    for (const model of settingsModels) {
+        const existingIndex = models.findIndex((candidate) => candidate.id === model.id);
+        if (existingIndex !== -1) {
+            const existing = models[existingIndex];
+            if (existing?.isSelectable === false) {
+                models[existingIndex] = { ...existing, ...model, isSelectable: true };
+            }
+            continue;
+        }
+        models.push(model);
+    }
+    return models;
+}
+async function readClaudeSettingsModels(logger, configDir) {
+    const settingsPath = path.join(resolveClaudeConfigDir(configDir), "settings.json");
+    let parsed;
+    try {
+        const rawSettings = await fs.readFile(settingsPath, "utf8");
+        parsed = JSON.parse(rawSettings);
+    }
+    catch (error) {
+        logger.debug({ err: error, settingsPath }, "Failed to read Claude settings models");
+        return [];
+    }
+    if (!isRecord(parsed)) {
+        logger.debug({ settingsPath }, "Claude settings.json is not an object");
+        return [];
+    }
+    const models = [];
+    addSettingsModel(models, parsed.model, "model");
+    const env = parsed.env;
+    if (env === undefined) {
+        return models;
+    }
+    if (!isRecord(env)) {
+        logger.debug({ settingsPath }, "Claude settings.json env is not an object");
+        return models;
+    }
+    for (const envKey of CLAUDE_SETTINGS_MODEL_ENV_KEYS) {
+        addSettingsModel(models, env[envKey], `env.${envKey}`);
+    }
+    return models;
+}
+function resolveClaudeConfigDir(configDir) {
+    return configDir ?? process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
+}
+function addSettingsModel(models, value, settingsKey) {
+    if (typeof value !== "string") {
+        return;
+    }
+    const id = value.trim();
+    if (id.length === 0 || models.some((model) => model.id === id)) {
+        return;
+    }
+    models.push({
+        provider: "claude",
+        id,
+        label: id,
+        description: `From Claude settings.json ${settingsKey}`,
+    });
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * Normalize a runtime model string (from SDK init message) to a known model ID.
+ * Handles the `[1m]` suffix that the SDK appends for 1M context sessions.
+ */
+export function normalizeClaudeRuntimeModelId(value) {
+    return normalizeClaudeManifestRuntimeModelId(value);
+}
+/**
+ * Placeholder model values Claude Code writes on frames with no real inference behind them.
+ * These are not models and must never be displayed.
+ */
+const CLAUDE_PLACEHOLDER_MODEL_IDS = new Set(["<synthetic>"]);
+/**
+ * Resolve a model id observed on a Claude assistant frame, for display.
+ *
+ * Prefers the manifest-normalized id so equivalent spellings collapse (a dated alias and a
+ * gateway prefix are the same model), but falls back to the raw string when the manifest does
+ * not know it. The fallback matters: Claude Code is an Anthropic-compatible client, so subagents
+ * routinely report models that are not Anthropic's — Z.AI GLM ids via `ANTHROPIC_BASE_URL`
+ * (docs/custom-providers.md) among them. Manifest-only resolution would blank the model for
+ * exactly those users.
+ *
+ * A `[1m]` suffix is preserved where it names its own manifest entry. Models such as Fable 5
+ * that only have a 1M entry normalize the retired suffixed spelling to the canonical ID.
+ *
+ * Returns null for placeholders and empty values, meaning "not observed".
+ */
+export function resolveObservedClaudeModelId(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (!trimmed || CLAUDE_PLACEHOLDER_MODEL_IDS.has(trimmed)) {
+        return null;
+    }
+    return normalizeClaudeManifestRuntimeModelId(trimmed) ?? trimmed;
+}
+//# sourceMappingURL=models.js.map

package/dist/server/server/agent/providers/claude/options.d.ts

@@ -0,0 +1,85 @@
+import type { ToolPolicy } from "@camerontaylor/paseo-protocol/agent-types";
+import { z } from "zod";
+export declare const ClaudeProviderOptionsSchema: z.ZodObject<{
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    disallowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    additionalDirectories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sandbox: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        failIfUnavailable: z.ZodOptional<z.ZodBoolean>;
+        autoAllowBashIfSandboxed: z.ZodOptional<z.ZodBoolean>;
+        excludedCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        allowUnsandboxedCommands: z.ZodOptional<z.ZodBoolean>;
+        network: z.ZodOptional<z.ZodObject<{
+            allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deniedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            strictAllowlist: z.ZodOptional<z.ZodBoolean>;
+            allowManagedDomainsOnly: z.ZodOptional<z.ZodBoolean>;
+            allowUnixSockets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowAllUnixSockets: z.ZodOptional<z.ZodBoolean>;
+            allowLocalBinding: z.ZodOptional<z.ZodBoolean>;
+            allowMachLookup: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            httpProxyPort: z.ZodOptional<z.ZodNumber>;
+            socksProxyPort: z.ZodOptional<z.ZodNumber>;
+            tlsTerminate: z.ZodOptional<z.ZodObject<{
+                caCertPath: z.ZodOptional<z.ZodString>;
+                caKeyPath: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        filesystem: z.ZodOptional<z.ZodObject<{
+            allowWrite: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            denyWrite: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            denyRead: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowRead: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowManagedReadPathsOnly: z.ZodOptional<z.ZodBoolean>;
+            disabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>>;
+        ignoreViolations: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+        enableWeakerNestedSandbox: z.ZodOptional<z.ZodBoolean>;
+        ripgrep: z.ZodOptional<z.ZodObject<{
+            command: z.ZodString;
+            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    settings: z.ZodOptional<z.ZodObject<{
+        permissions: z.ZodOptional<z.ZodObject<{
+            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            ask: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        sandbox: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            failIfUnavailable: z.ZodOptional<z.ZodBoolean>;
+            autoAllowBashIfSandboxed: z.ZodOptional<z.ZodBoolean>;
+            excludedCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            allowUnsandboxedCommands: z.ZodOptional<z.ZodBoolean>;
+            network: z.ZodOptional<z.ZodObject<{
+                allowedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                deniedDomains: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                strictAllowlist: z.ZodOptional<z.ZodBoolean>;
+                allowManagedDomainsOnly: z.ZodOptional<z.ZodBoolean>;
+                allowUnixSockets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowAllUnixSockets: z.ZodOptional<z.ZodBoolean>;
+                allowLocalBinding: z.ZodOptional<z.ZodBoolean>;
+                allowMachLookup: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                httpProxyPort: z.ZodOptional<z.ZodNumber>;
+                socksProxyPort: z.ZodOptional<z.ZodNumber>;
+                tlsTerminate: z.ZodOptional<z.ZodObject<{
+                    caCertPath: z.ZodOptional<z.ZodString>;
+                    caKeyPath: z.ZodOptional<z.ZodString>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+            filesystem: z.ZodOptional<z.ZodObject<{
+                allowWrite: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                denyWrite: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                denyRead: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowRead: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                allowManagedReadPathsOnly: z.ZodOptional<z.ZodBoolean>;
+                disabled: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ClaudeProviderOptions = z.infer<typeof ClaudeProviderOptionsSchema>;
+export declare function applyClaudeToolPolicy(options: ClaudeProviderOptions, toolPolicy: ToolPolicy | undefined): ClaudeProviderOptions;
+//# sourceMappingURL=options.d.ts.map

package/dist/server/server/agent/providers/claude/options.js

@@ -0,0 +1,93 @@
+import { z } from "zod";
+const PermissionRulesSchema = z
+    .object({
+    allow: z.array(z.string()).optional(),
+    ask: z.array(z.string()).optional(),
+    deny: z.array(z.string()).optional(),
+})
+    .strict();
+const SandboxNetworkSchema = z
+    .object({
+    allowedDomains: z.array(z.string()).optional(),
+    deniedDomains: z.array(z.string()).optional(),
+    strictAllowlist: z.boolean().optional(),
+    allowManagedDomainsOnly: z.boolean().optional(),
+    allowUnixSockets: z.array(z.string()).optional(),
+    allowAllUnixSockets: z.boolean().optional(),
+    allowLocalBinding: z.boolean().optional(),
+    allowMachLookup: z.array(z.string()).optional(),
+    httpProxyPort: z.number().int().positive().optional(),
+    socksProxyPort: z.number().int().positive().optional(),
+    tlsTerminate: z
+        .object({
+        caCertPath: z.string().optional(),
+        caKeyPath: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+const SandboxFilesystemSchema = z
+    .object({
+    allowWrite: z.array(z.string()).optional(),
+    denyWrite: z.array(z.string()).optional(),
+    denyRead: z.array(z.string()).optional(),
+    allowRead: z.array(z.string()).optional(),
+    allowManagedReadPathsOnly: z.boolean().optional(),
+    disabled: z.boolean().optional(),
+})
+    .strict();
+// Claude Agent SDK Options, maintained against @anthropic-ai/claude-agent-sdk 0.3.246.
+export const ClaudeProviderOptionsSchema = z
+    .object({
+    allowedTools: z.array(z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+    additionalDirectories: z.array(z.string()).optional(),
+    sandbox: z
+        .object({
+        enabled: z.boolean().optional(),
+        failIfUnavailable: z.boolean().optional(),
+        autoAllowBashIfSandboxed: z.boolean().optional(),
+        excludedCommands: z.array(z.string()).optional(),
+        allowUnsandboxedCommands: z.boolean().optional(),
+        network: SandboxNetworkSchema.optional(),
+        filesystem: SandboxFilesystemSchema.optional(),
+        ignoreViolations: z.record(z.string(), z.array(z.string())).optional(),
+        enableWeakerNestedSandbox: z.boolean().optional(),
+        ripgrep: z
+            .object({ command: z.string(), args: z.array(z.string()).optional() })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    settings: z
+        .object({
+        permissions: PermissionRulesSchema.optional(),
+        sandbox: z
+            .object({
+            enabled: z.boolean().optional(),
+            failIfUnavailable: z.boolean().optional(),
+            autoAllowBashIfSandboxed: z.boolean().optional(),
+            excludedCommands: z.array(z.string()).optional(),
+            allowUnsandboxedCommands: z.boolean().optional(),
+            network: SandboxNetworkSchema.optional(),
+            filesystem: SandboxFilesystemSchema.optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+export function applyClaudeToolPolicy(options, toolPolicy) {
+    if (!toolPolicy)
+        return options;
+    const allowedTools = Array.isArray(options.allowedTools)
+        ? options.allowedTools.filter((tool) => typeof tool === "string")
+        : [];
+    const grants = toolPolicy.preapproved.map((grant) => `mcp__${grant.server}__${grant.tool}`);
+    return { ...options, allowedTools: [...new Set([...allowedTools, ...grants])] };
+}
+//# sourceMappingURL=options.js.map

package/dist/server/server/agent/providers/claude/partial-json.d.ts

@@ -0,0 +1,5 @@
+export declare function parsePartialJsonObject(input: string): {
+    value: Record<string, unknown>;
+    complete: boolean;
+} | null;
+//# sourceMappingURL=partial-json.d.ts.map

package/dist/server/server/agent/providers/claude/partial-json.js

@@ -0,0 +1,306 @@
+function skipWhitespace(input, index) {
+    let currentIndex = index;
+    while (currentIndex < input.length && /\s/u.test(input[currentIndex] ?? "")) {
+        currentIndex += 1;
+    }
+    return currentIndex;
+}
+function parsePartialString(input, index) {
+    if (input[index] !== '"') {
+        return null;
+    }
+    let currentIndex = index + 1;
+    let value = "";
+    while (currentIndex < input.length) {
+        const character = input[currentIndex];
+        if (character === '"') {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (character === "\\") {
+            const escapeCharacter = input[currentIndex + 1];
+            if (escapeCharacter === undefined) {
+                return {
+                    value,
+                    nextIndex: input.length,
+                    complete: false,
+                };
+            }
+            switch (escapeCharacter) {
+                case '"':
+                case "\\":
+                case "/":
+                    value += escapeCharacter;
+                    currentIndex += 2;
+                    continue;
+                case "b":
+                    value += "\b";
+                    currentIndex += 2;
+                    continue;
+                case "f":
+                    value += "\f";
+                    currentIndex += 2;
+                    continue;
+                case "n":
+                    value += "\n";
+                    currentIndex += 2;
+                    continue;
+                case "r":
+                    value += "\r";
+                    currentIndex += 2;
+                    continue;
+                case "t":
+                    value += "\t";
+                    currentIndex += 2;
+                    continue;
+                case "u": {
+                    const hex = input.slice(currentIndex + 2, currentIndex + 6);
+                    if (hex.length < 4 || !/^[0-9a-fA-F]{4}$/u.test(hex)) {
+                        return {
+                            value,
+                            nextIndex: input.length,
+                            complete: false,
+                        };
+                    }
+                    value += String.fromCodePoint(Number.parseInt(hex, 16));
+                    currentIndex += 6;
+                    continue;
+                }
+                default:
+                    return {
+                        value,
+                        nextIndex: input.length,
+                        complete: false,
+                    };
+            }
+        }
+        value += character;
+        currentIndex += 1;
+    }
+    return {
+        value,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialLiteral(input, index) {
+    const remaining = input.slice(index);
+    if (remaining.startsWith("true")) {
+        return { value: true, nextIndex: index + 4, complete: true };
+    }
+    if (remaining.startsWith("false")) {
+        return { value: false, nextIndex: index + 5, complete: true };
+    }
+    if (remaining.startsWith("null")) {
+        return { value: null, nextIndex: index + 4, complete: true };
+    }
+    return null;
+}
+function parsePartialNumber(input, index) {
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/u.exec(input.slice(index));
+    if (!match?.[0]) {
+        return null;
+    }
+    return {
+        value: Number(match[0]),
+        nextIndex: index + match[0].length,
+        complete: true,
+    };
+}
+function parsePartialArray(input, index) {
+    if (input[index] !== "[") {
+        return null;
+    }
+    const values = [];
+    let currentIndex = index + 1;
+    while (currentIndex <= input.length) {
+        currentIndex = skipWhitespace(input, currentIndex);
+        const nextCharacter = input[currentIndex];
+        if (nextCharacter === "]") {
+            return {
+                value: values,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (nextCharacter === undefined) {
+            return {
+                value: values,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        const parsedValue = parsePartialJsonValue(input, currentIndex);
+        if (!parsedValue) {
+            return {
+                value: values,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        values.push(parsedValue.value);
+        currentIndex = skipWhitespace(input, parsedValue.nextIndex);
+        if (!parsedValue.complete) {
+            return {
+                value: values,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        const delimiter = input[currentIndex];
+        if (delimiter === ",") {
+            currentIndex += 1;
+            continue;
+        }
+        if (delimiter === "]") {
+            return {
+                value: values,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (delimiter === undefined) {
+            return {
+                value: values,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        return {
+            value: values,
+            nextIndex: currentIndex,
+            complete: false,
+        };
+    }
+    return {
+        value: values,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialObject(input, index) {
+    if (input[index] !== "{") {
+        return null;
+    }
+    const value = {};
+    let currentIndex = index + 1;
+    while (currentIndex <= input.length) {
+        currentIndex = skipWhitespace(input, currentIndex);
+        const nextCharacter = input[currentIndex];
+        if (nextCharacter === "}") {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (nextCharacter === undefined) {
+            return {
+                value,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        const parsedKey = parsePartialString(input, currentIndex);
+        if (!parsedKey?.complete) {
+            return {
+                value,
+                nextIndex: parsedKey?.nextIndex ?? currentIndex,
+                complete: false,
+            };
+        }
+        currentIndex = skipWhitespace(input, parsedKey.nextIndex);
+        if (input[currentIndex] !== ":") {
+            return {
+                value,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        currentIndex = skipWhitespace(input, currentIndex + 1);
+        const parsedMemberValue = parsePartialJsonValue(input, currentIndex);
+        if (!parsedMemberValue) {
+            return {
+                value,
+                nextIndex: currentIndex,
+                complete: false,
+            };
+        }
+        if (!parsedMemberValue.complete) {
+            return {
+                value,
+                nextIndex: skipWhitespace(input, parsedMemberValue.nextIndex),
+                complete: false,
+            };
+        }
+        value[parsedKey.value] = parsedMemberValue.value;
+        currentIndex = skipWhitespace(input, parsedMemberValue.nextIndex);
+        const delimiter = input[currentIndex];
+        if (delimiter === ",") {
+            currentIndex += 1;
+            continue;
+        }
+        if (delimiter === "}") {
+            return {
+                value,
+                nextIndex: currentIndex + 1,
+                complete: true,
+            };
+        }
+        if (delimiter === undefined) {
+            return {
+                value,
+                nextIndex: input.length,
+                complete: false,
+            };
+        }
+        return {
+            value,
+            nextIndex: currentIndex,
+            complete: false,
+        };
+    }
+    return {
+        value,
+        nextIndex: input.length,
+        complete: false,
+    };
+}
+function parsePartialJsonValue(input, index) {
+    const currentIndex = skipWhitespace(input, index);
+    const character = input[currentIndex];
+    if (character === undefined) {
+        return null;
+    }
+    if (character === '"') {
+        return parsePartialString(input, currentIndex);
+    }
+    if (character === "{") {
+        return parsePartialObject(input, currentIndex);
+    }
+    if (character === "[") {
+        return parsePartialArray(input, currentIndex);
+    }
+    if (character === "t" || character === "f" || character === "n") {
+        return parsePartialLiteral(input, currentIndex);
+    }
+    if (character === "-" || /\d/u.test(character)) {
+        return parsePartialNumber(input, currentIndex);
+    }
+    return null;
+}
+export function parsePartialJsonObject(input) {
+    const currentIndex = skipWhitespace(input, 0);
+    const parsed = parsePartialObject(input, currentIndex);
+    if (!parsed) {
+        return null;
+    }
+    return {
+        value: parsed.value,
+        complete: parsed.complete && skipWhitespace(input, parsed.nextIndex) === input.length,
+    };
+}
+//# sourceMappingURL=partial-json.js.map

package/dist/server/server/agent/providers/claude/project-dir.d.ts

@@ -0,0 +1,6 @@
+export interface ClaudeProjectDirOptions {
+    configDir?: string;
+}
+export declare function claudeProjectDir(cwd: string, options?: ClaudeProjectDirOptions): Promise<string>;
+export declare function claudeProjectDirSync(cwd: string, options?: ClaudeProjectDirOptions): string;
+//# sourceMappingURL=project-dir.d.ts.map

package/dist/server/server/agent/providers/claude/project-dir.js

@@ -0,0 +1,57 @@
+import { realpathSync } from "node:fs";
+import { realpath } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+// Verbatim port of the Claude Agent SDK's project-directory encoding so
+// paseo computes the same `~/.claude/projects/<dir>` path the SDK does.
+// The SDK ships only as a precompiled bundle; grep the JS source at
+// node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs for `function Ar`,
+// `function So`, `async function wn`, `function Dy`, `Ni=200`.
+const PROJECT_DIR_LENGTH_CAP = 200;
+export async function claudeProjectDir(cwd, options) {
+    const canonical = await canonicalize(cwd);
+    const projectsRoot = join(resolveConfigDir(options), "projects");
+    return join(projectsRoot, encode(canonical));
+}
+export function claudeProjectDirSync(cwd, options) {
+    const canonical = canonicalizeSync(cwd);
+    const projectsRoot = join(resolveConfigDir(options), "projects");
+    return join(projectsRoot, encode(canonical));
+}
+async function canonicalize(input) {
+    try {
+        return normalizeProjectPath(await realpath(input));
+    }
+    catch {
+        return normalizeProjectPath(input);
+    }
+}
+function canonicalizeSync(input) {
+    try {
+        return normalizeProjectPath(realpathSync.native(input));
+    }
+    catch {
+        return normalizeProjectPath(input);
+    }
+}
+function normalizeProjectPath(input) {
+    return process.platform === "darwin" ? input.normalize("NFC") : input;
+}
+function encode(input) {
+    const replaced = input.replace(/[^a-zA-Z0-9]/g, "-");
+    if (replaced.length <= PROJECT_DIR_LENGTH_CAP) {
+        return replaced;
+    }
+    return `${replaced.slice(0, PROJECT_DIR_LENGTH_CAP)}-${hashSuffix(input)}`;
+}
+function hashSuffix(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+function resolveConfigDir(options) {
+    return options?.configDir ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
+}
+//# sourceMappingURL=project-dir.js.map