@undefineds.co/xpod 0.4.20 → 0.4.25

package/dist/cli/agent-fs/roots.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePodRoot = normalizePodRoot;
+exports.parseManagedRoots = parseManagedRoots;
+exports.loadManagedRoots = loadManagedRoots;
+exports.resolveManagedTarget = resolveManagedTarget;
+exports.displayPrefixFor = displayPrefixFor;
+exports.stripPrefix = stripPrefix;
+exports.hasHiddenSegment = hasHiddenSegment;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function normalizePodRoot(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return undefined;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        return undefined;
+    }
+    // A managed root must be a canonical container URL: no query, hash or userinfo.
+    if (url.search !== '' || url.hash !== '' || url.username !== '' || url.password !== '') {
+        return undefined;
+    }
+    return url.href.endsWith('/') ? url.href : `${url.href}/`;
+}
+function toPosix(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}
+function withTrailingSlash(relative) {
+    return relative.length === 0 ? '' : `${relative.replace(/\/+$/, '')}/`;
+}
+function realpathOrUndefined(value) {
+    try {
+        return (0, node_fs_1.realpathSync)(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isWithin(root, candidate) {
+    return candidate === root || candidate.startsWith(`${root}${node_path_1.default.sep}`);
+}
+function parseManagedRoots(raw) {
+    if (!Array.isArray(raw)) {
+        return [];
+    }
+    const roots = [];
+    for (const item of raw) {
+        if (!item || typeof item !== 'object') {
+            continue;
+        }
+        const candidate = item;
+        if (typeof candidate.localPath !== 'string' || typeof candidate.podRoot !== 'string') {
+            continue;
+        }
+        const podRoot = normalizePodRoot(candidate.podRoot);
+        if (!podRoot) {
+            continue;
+        }
+        roots.push({ localPath: node_path_1.default.resolve(candidate.localPath), podRoot });
+    }
+    // Longest local prefix first so nested roots resolve to the most specific one.
+    roots.sort((left, right) => right.localPath.length - left.localPath.length);
+    return roots;
+}
+function loadManagedRoots(env = process.env) {
+    const inline = env.XPOD_AGENT_FS_ROOTS;
+    if (inline) {
+        try {
+            return parseManagedRoots(JSON.parse(inline));
+        }
+        catch {
+            return [];
+        }
+    }
+    const file = env.XPOD_AGENT_FS_ROOTS_FILE;
+    if (file) {
+        try {
+            return parseManagedRoots(JSON.parse((0, node_fs_1.readFileSync)(file, 'utf8')));
+        }
+        catch {
+            return [];
+        }
+    }
+    return [];
+}
+function resolveManagedTarget(cwd, pathArg, roots) {
+    const absoluteCwd = node_path_1.default.resolve(cwd);
+    const absoluteTarget = node_path_1.default.resolve(absoluteCwd, pathArg ?? '.');
+    // Trust the real filesystem identity, not string prefixes: a symlink inside
+    // the root may point outside it.
+    const realCwd = realpathOrUndefined(absoluteCwd);
+    const realTarget = realpathOrUndefined(absoluteTarget);
+    if (!realCwd || !realTarget) {
+        return undefined;
+    }
+    const root = roots.find((candidate) => {
+        const realRoot = realpathOrUndefined(candidate.localPath);
+        return realRoot !== undefined && isWithin(realRoot, realCwd);
+    });
+    if (!root) {
+        return undefined;
+    }
+    const realRoot = realpathOrUndefined(root.localPath);
+    if (!realRoot || !isWithin(realRoot, realTarget)) {
+        return undefined;
+    }
+    // Directory targets only in this batch. An explicit file path would become a
+    // directory prefix and produce a false zero-hit result, so fall back instead.
+    let stats;
+    try {
+        stats = (0, node_fs_1.statSync)(realTarget);
+    }
+    catch {
+        return undefined;
+    }
+    if (!stats.isDirectory()) {
+        return undefined;
+    }
+    return {
+        root,
+        relCwd: withTrailingSlash(toPosix(node_path_1.default.relative(realRoot, realCwd))),
+        relFromRoot: withTrailingSlash(toPosix(node_path_1.default.relative(realRoot, realTarget))),
+    };
+}
+function displayPrefixFor(pathArg) {
+    if (pathArg === undefined) {
+        return '';
+    }
+    if (pathArg === '.') {
+        return './';
+    }
+    return pathArg.endsWith('/') ? pathArg : `${pathArg}/`;
+}
+function stripPrefix(entryPath, prefix) {
+    if (!prefix) {
+        return entryPath;
+    }
+    return entryPath.startsWith(prefix) ? entryPath.slice(prefix.length) : entryPath;
+}
+function hasHiddenSegment(relativePath) {
+    return relativePath
+        .split('/')
+        .some((segment) => segment.length > 0 && segment !== '.' && segment !== '..' && segment.startsWith('.'));
+}
+//# sourceMappingURL=roots.js.map

package/dist/cli/agent-fs/runner.d.ts

@@ -0,0 +1,18 @@
+import { AgentDirectoryClient } from '../../agent-directory/client/AgentDirectoryClient';
+import type { RgInvocation } from './args';
+import { type ManagedRoot } from './roots';
+export declare class ManagedTargetUnresolvedError extends Error {
+    constructor(reason: string);
+}
+export interface ManagedRunDependencies {
+    client: AgentDirectoryClient;
+    cwd: string;
+    roots: ManagedRoot[];
+    stdoutIsTty: boolean;
+}
+export interface ManagedRunResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+}
+export declare function runManagedInvocation(invocation: RgInvocation, deps: ManagedRunDependencies): Promise<ManagedRunResult>;

package/dist/cli/agent-fs/runner.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManagedTargetUnresolvedError = void 0;
+exports.runManagedInvocation = runManagedInvocation;
+const roots_1 = require("./roots");
+class ManagedTargetUnresolvedError extends Error {
+    constructor(reason) {
+        super(reason);
+        this.name = 'ManagedTargetUnresolvedError';
+    }
+}
+exports.ManagedTargetUnresolvedError = ManagedTargetUnresolvedError;
+/** Non-zero code used for any incomplete managed scan (partial or not). */
+const INCOMPLETE_EXIT_CODE = 2;
+async function runManagedInvocation(invocation, deps) {
+    const target = (0, roots_1.resolveManagedTarget)(deps.cwd, invocation.pathArg, deps.roots);
+    if (!target) {
+        throw new ManagedTargetUnresolvedError('cwd or path argument is outside the configured managed Pod roots');
+    }
+    if (invocation.kind === 'files') {
+        return runFiles(invocation, target.root.podRoot, target.relFromRoot, deps);
+    }
+    return runSearch(invocation, target.root.podRoot, target.relFromRoot, deps);
+}
+async function runFiles(invocation, podRoot, relFromRoot, deps) {
+    const listing = await deps.client.listAll({
+        root: podRoot,
+        ...(relFromRoot ? { pathPrefix: relFromRoot } : {}),
+    });
+    const prefix = (0, roots_1.displayPrefixFor)(invocation.pathArg);
+    const lines = [];
+    for (const entry of listing.entries) {
+        if (entry.type !== 'file') {
+            continue;
+        }
+        const relativeToTarget = (0, roots_1.stripPrefix)(entry.path, relFromRoot);
+        if (!invocation.hidden && (0, roots_1.hasHiddenSegment)(relativeToTarget)) {
+            continue;
+        }
+        lines.push(`${prefix}${relativeToTarget}`);
+    }
+    if (!listing.complete) {
+        return {
+            stdout: lines.length > 0 ? `${lines.join('\n')}\n` : '',
+            stderr: 'xpod-rg: warning: directory listing was incomplete\n',
+            exitCode: INCOMPLETE_EXIT_CODE,
+        };
+    }
+    return {
+        stdout: lines.length > 0 ? `${lines.join('\n')}\n` : '',
+        stderr: '',
+        exitCode: lines.length > 0 ? 0 : 1,
+    };
+}
+async function runSearch(invocation, podRoot, relFromRoot, deps) {
+    const response = await deps.client.searchAll({
+        root: podRoot,
+        query: invocation.query,
+        ignoreCase: invocation.ignoreCase,
+        ...(relFromRoot ? { pathPrefix: relFromRoot } : {}),
+    });
+    const prefix = (0, roots_1.displayPrefixFor)(invocation.pathArg);
+    const lineNumber = invocation.lineNumber ?? false;
+    const visibleMatches = response.matches.filter((match) => {
+        const relativeToTarget = (0, roots_1.stripPrefix)(match.path, relFromRoot);
+        return invocation.hidden || !(0, roots_1.hasHiddenSegment)(relativeToTarget);
+    });
+    // ripgrep's default output prints one line per matching line and -c counts
+    // matching lines, not occurrences; collapse duplicates by (path, line).
+    const uniqueMatches = dedupeMatches(visibleMatches, relFromRoot);
+    const lines = [];
+    if (invocation.filesWithMatches) {
+        const seen = new Set();
+        for (const match of uniqueMatches) {
+            const relativeToTarget = (0, roots_1.stripPrefix)(match.path, relFromRoot);
+            if (seen.has(relativeToTarget)) {
+                continue;
+            }
+            seen.add(relativeToTarget);
+            lines.push(`${prefix}${relativeToTarget}`);
+        }
+    }
+    else if (invocation.count) {
+        const counts = new Map();
+        for (const match of uniqueMatches) {
+            const relativeToTarget = (0, roots_1.stripPrefix)(match.path, relFromRoot);
+            const entry = counts.get(relativeToTarget) ?? { display: `${prefix}${relativeToTarget}`, count: 0 };
+            entry.count += 1;
+            counts.set(relativeToTarget, entry);
+        }
+        for (const entry of [...counts.values()].sort((left, right) => (left.display < right.display ? -1 : 1))) {
+            lines.push(`${entry.display}:${entry.count}`);
+        }
+    }
+    else {
+        for (const match of sortMatches(uniqueMatches, relFromRoot)) {
+            const relativeToTarget = (0, roots_1.stripPrefix)(match.path, relFromRoot);
+            const location = lineNumber ? `${match.line}:` : '';
+            lines.push(`${prefix}${relativeToTarget}:${location}${match.text}`);
+        }
+    }
+    const hasMatches = uniqueMatches.length > 0;
+    const complete = response.complete && !response.hasUnscannedScope;
+    if (!complete) {
+        // Partial results must never be presented as a successful full scan, even
+        // when some matches were found. Emit the partial output but fail.
+        return {
+            stdout: lines.length > 0 ? `${lines.join('\n')}\n` : '',
+            stderr: 'xpod-rg: warning: search scope was not fully scanned\n',
+            exitCode: INCOMPLETE_EXIT_CODE,
+        };
+    }
+    return {
+        stdout: lines.length > 0 ? `${lines.join('\n')}\n` : '',
+        stderr: '',
+        exitCode: hasMatches ? 0 : 1,
+    };
+}
+function dedupeMatches(matches, relFromRoot) {
+    const seen = new Set();
+    const result = [];
+    for (const match of matches) {
+        const key = `${(0, roots_1.stripPrefix)(match.path, relFromRoot)}\u0000${match.line}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        result.push(match);
+    }
+    return result;
+}
+function sortMatches(matches, relFromRoot) {
+    return [...matches].sort((left, right) => {
+        const leftPath = (0, roots_1.stripPrefix)(left.path, relFromRoot);
+        const rightPath = (0, roots_1.stripPrefix)(right.path, relFromRoot);
+        if (leftPath !== rightPath) {
+            return leftPath < rightPath ? -1 : 1;
+        }
+        if (left.line !== right.line) {
+            return left.line - right.line;
+        }
+        return left.column - right.column;
+    });
+}
+//# sourceMappingURL=runner.js.map

package/dist/cli/agent-fs/session-view.d.ts

@@ -0,0 +1,7 @@
+export declare function defaultSessionDir(env?: NodeJS.ProcessEnv): string;
+/** Read-only observation of the native journal; Rust remains its sole writer. */
+export declare function observeSession(dir: string): {
+    version: string;
+    podRoot?: string;
+    pending: number;
+};

package/dist/cli/agent-fs/session-view.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSessionDir = defaultSessionDir;
+exports.observeSession = observeSession;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+function defaultSessionDir(env = process.env) {
+    return node_path_1.default.resolve(env.XPOD_AGENTFS_SESSION || node_path_1.default.join(env.HOME ?? '.', '.xpod', 'agentfs'));
+}
+/** Read-only observation of the native journal; Rust remains its sole writer. */
+function observeSession(dir) {
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(node_path_1.default.join(dir, 'session.json'), 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { version: '', pending: 0 };
+        }
+        throw error;
+    }
+    const state = JSON.parse(raw);
+    if (typeof state.pod_root !== 'string' || !state.entries || typeof state.entries !== 'object' || Array.isArray(state.entries)) {
+        throw new Error('Invalid native session manifest; pending state cannot be determined');
+    }
+    return { version: raw, podRoot: state.pod_root, pending: Object.keys(state.entries).length };
+}
+//# sourceMappingURL=session-view.js.map

package/dist/cli/commands/agent-fs.d.ts

@@ -0,0 +1,2 @@
+import type { CommandModule } from 'yargs';
+export declare const agentFsCommand: CommandModule;