peaks-loop 4.0.0-beta.8 → 4.0.1

package/dist/shared/frontmatter.js

@@ -0,0 +1,165 @@
+const KEY_PATTERN = /^([A-Za-z0-9_.-]+):\s*(.*)$/;
+/**
+ * Flatten a nested YAML mapping (max 2 levels deep) into dotted keys.
+ * `metadata:\n  appliesTo: v2.12.0+` → `metadata.appliesTo: v2.12.0+`.
+ * `metadata:\n  sources:\n    - foo\n    - bar` →
+ *   `metadata.sources: foo, bar`.
+ *
+ * Skills only use this shape for the `metadata:` block (v2.12.0
+ * skill-versioning contract); deeper nesting is not currently emitted.
+ */
+function flattenNestedFrontmatter(frontmatterLines) {
+    const flat = [];
+    let i = 0;
+    while (i < frontmatterLines.length) {
+        const line = frontmatterLines[i];
+        if (line === undefined) {
+            i += 1;
+            continue;
+        }
+        if (line.trim().length === 0) {
+            flat.push(line);
+            i += 1;
+            continue;
+        }
+        const parentMatch = /^([A-Za-z0-9_-]+):\s*$/.exec(line);
+        if (!parentMatch || parentMatch[1] === undefined) {
+            flat.push(line);
+            i += 1;
+            continue;
+        }
+        const parent = parentMatch[1];
+        // Collect children (2nd-level keys OR list items OR a 2nd-level parent key).
+        const children = [];
+        let listItemsAtParent = [];
+        let grandTotalConsumed = 0;
+        let j = i + 1;
+        while (j < frontmatterLines.length) {
+            const childLine = frontmatterLines[j];
+            if (childLine === undefined || childLine.trim().length === 0)
+                break;
+            // 2nd-level parent key (e.g. "  sources:") — recurse one level.
+            const subParentMatch = /^\s{2,}([A-Za-z0-9_-]+):\s*$/.exec(childLine);
+            if (subParentMatch && subParentMatch[1] !== undefined) {
+                const subParent = subParentMatch[1];
+                const subList = [];
+                let k = j + 1;
+                let subConsumed = 0;
+                while (k < frontmatterLines.length) {
+                    const gcLine = frontmatterLines[k];
+                    if (gcLine === undefined || gcLine.trim().length === 0)
+                        break;
+                    const li = /^\s+-\s+(.+)$/.exec(gcLine);
+                    if (li && li[1] !== undefined) {
+                        subList.push(li[1].trim());
+                        subConsumed += 1;
+                        k += 1;
+                        continue;
+                    }
+                    break;
+                }
+                if (subList.length > 0) {
+                    children.push({ key: subParent, listItems: subList, grandChildren: [] });
+                }
+                else {
+                    // Empty sub-parent; preserve as bare key (no value).
+                    children.push({ key: subParent, listItems: [], grandChildren: [] });
+                }
+                grandTotalConsumed += subConsumed + 1;
+                j = k;
+                continue;
+            }
+            // Direct list item under parent (no nested key).
+            const directList = /^\s+-\s+(.+)$/.exec(childLine);
+            if (directList && directList[1] !== undefined) {
+                listItemsAtParent.push(directList[1].trim());
+                grandTotalConsumed += 1;
+                j += 1;
+                continue;
+            }
+            // 2nd-level scalar key.
+            const scalarMatch = /^\s{2,}([A-Za-z0-9_-]+):\s*(.*)$/.exec(childLine);
+            if (scalarMatch && scalarMatch[1] !== undefined) {
+                children.push({
+                    key: scalarMatch[1],
+                    listItems: [],
+                    grandChildren: [`${parent}.${scalarMatch[1]}: ${scalarMatch[2] ?? ''}`.trimEnd()]
+                });
+                grandTotalConsumed += 1;
+                j += 1;
+                continue;
+            }
+            break;
+        }
+        if (listItemsAtParent.length > 0) {
+            flat.push(`${parent}: ${listItemsAtParent.join(', ')}`);
+        }
+        else if (children.length > 0) {
+            for (const child of children) {
+                if (child.listItems.length > 0) {
+                    flat.push(`${parent}.${child.key}: ${child.listItems.join(', ')}`);
+                }
+                else if (child.grandChildren.length > 0) {
+                    for (const gc of child.grandChildren)
+                        flat.push(gc);
+                }
+                else {
+                    flat.push(`${parent}.${child.key}:`);
+                }
+            }
+        }
+        else {
+            flat.push(line);
+        }
+        i += grandTotalConsumed + 1;
+    }
+    return flat;
+}
+export function parseFrontmatter(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    if (lines[0] !== '---') {
+        throw new Error('Missing YAML frontmatter opening marker');
+    }
+    const endIndex = lines.findIndex((line, index) => index > 0 && line === '---');
+    if (endIndex === -1) {
+        throw new Error('Missing YAML frontmatter closing marker');
+    }
+    const rawLines = lines.slice(1, endIndex);
+    const frontmatterLines = flattenNestedFrontmatter(rawLines);
+    const metadata = {};
+    for (let index = 0; index < frontmatterLines.length; index += 1) {
+        const line = frontmatterLines[index];
+        if (!line || line.trim().length === 0) {
+            continue;
+        }
+        const blockMatch = line.match(/^([A-Za-z0-9_-]+):\s*[|>]\s*$/);
+        if (blockMatch?.[1]) {
+            const key = blockMatch[1];
+            const blockLines = [];
+            index += 1;
+            while (index < frontmatterLines.length) {
+                const blockLine = frontmatterLines[index];
+                if (blockLine && /^\S[^:]*:/.test(blockLine)) {
+                    index -= 1;
+                    break;
+                }
+                blockLines.push(blockLine?.replace(/^\s{2}/, '') ?? '');
+                index += 1;
+            }
+            metadata[key] = blockLines.join('\n').trim();
+            continue;
+        }
+        const match = line.match(KEY_PATTERN);
+        if (!match?.[1]) {
+            throw new Error(`Invalid frontmatter line: ${line}`);
+        }
+        metadata[match[1]] = (match[2] ?? '').trim().replace(/^['"]|['"]$/g, '');
+    }
+    if (!metadata.name) {
+        throw new Error('Missing required frontmatter field: name');
+    }
+    if (!metadata.description) {
+        throw new Error('Missing required frontmatter field: description');
+    }
+    return metadata;
+}

package/dist/shared/fs-utils.d.ts

@@ -0,0 +1,4 @@
+import type { Platform } from './platform.js';
+export declare function getDirectoryLinkType(targetPlatform?: Platform): 'junction' | 'dir';
+export declare function createDirectoryLinkSync(target: string, linkPath: string): void;
+export declare function readDirectoryLinkTarget(linkPath: string): string | null;

package/dist/shared/fs-utils.js

@@ -0,0 +1,16 @@
+import { symlinkSync as nodeSymlinkSync, readlinkSync } from 'node:fs';
+import { platform } from './platform.js';
+export function getDirectoryLinkType(targetPlatform = platform) {
+    return targetPlatform === 'win32' ? 'junction' : 'dir';
+}
+export function createDirectoryLinkSync(target, linkPath) {
+    nodeSymlinkSync(target, linkPath, getDirectoryLinkType());
+}
+export function readDirectoryLinkTarget(linkPath) {
+    try {
+        return readlinkSync(linkPath);
+    }
+    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        return null;
+    }
+}

package/dist/shared/incrementing-number.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Utilities for generating incrementing numbered filenames.
+ * Used by session-based artifact storage to create files like 001-feature.md.
+ */
+/**
+ * Get the next available number in a directory.
+ * Scans existing .md files and finds the highest numeric prefix.
+ * Returns 1 if directory is empty or doesn't exist.
+ *
+ * @param dirPath - Directory to scan for numbered files
+ * @returns Next available number (1, 2, 3, ...)
+ */
+export declare function getNextNumber(dirPath: string): number;
+export declare function buildNumberedFilename(number: number, description: string): string;
+/**
+ * Get the next numbered file path in a directory.
+ * Combines getNextNumber() and buildNumberedFilename().
+ *
+ * @param dirPath - Directory to scan
+ * @param description - Description for the filename
+ * @returns Full path to the new numbered file
+ */
+export declare function getNextNumberedFilePath(dirPath: string, description: string): string;

package/dist/shared/incrementing-number.js

@@ -0,0 +1,68 @@
+/**
+ * Utilities for generating incrementing numbered filenames.
+ * Used by session-based artifact storage to create files like 001-feature.md.
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+/**
+ * Get the next available number in a directory.
+ * Scans existing .md files and finds the highest numeric prefix.
+ * Returns 1 if directory is empty or doesn't exist.
+ *
+ * @param dirPath - Directory to scan for numbered files
+ * @returns Next available number (1, 2, 3, ...)
+ */
+export function getNextNumber(dirPath) {
+    if (!existsSync(dirPath))
+        return 1;
+    const files = readdirSync(dirPath).filter(f => f.endsWith('.md'));
+    if (files.length === 0)
+        return 1;
+    const numbers = files
+        .map(f => {
+        const match = /^(\d+)-/.exec(f);
+        return match && match[1] ? parseInt(match[1], 10) : NaN;
+    })
+        .filter(n => !isNaN(n));
+    return numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
+}
+/**
+ * Build a numbered filename from a number and description.
+ * Format: 001-description-slug.md
+ *
+ * @param number - The file number (will be zero-padded to 3 digits)
+ * @param description - Human-readable description (converted to kebab-case slug)
+ * @returns Formatted filename like "001-feature-name.md"
+ */
+// Windows supports up to 255 chars per filename component (and 260 for the
+// full path). Pre-#015 the slug was silently truncated to 50 chars, which
+// produced orphaned artefacts (the on-disk file no longer matched the
+// request-id and the state machine could not find it). 255 is the OS-level
+// ceiling; if a requestId exceeds that, `mkdir` / `writeFile` will surface a
+// real ENAMETOOLONG error instead of a silent mismatch. We reserve 4 chars
+// for the `<NNN>-` numeric prefix and 3 chars for the `.md` suffix, so
+// the slug may be at most 248 chars (giving 4 + 248 + 3 = 255 total).
+const MAX_FILENAME_LENGTH = 255;
+const MAX_FILENAME_SLUG_LENGTH = MAX_FILENAME_LENGTH - 7;
+export function buildNumberedFilename(number, description) {
+    const padded = String(number).padStart(3, '0');
+    const slug = description
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '')
+        .slice(0, MAX_FILENAME_SLUG_LENGTH);
+    return `${padded}-${slug}.md`;
+}
+/**
+ * Get the next numbered file path in a directory.
+ * Combines getNextNumber() and buildNumberedFilename().
+ *
+ * @param dirPath - Directory to scan
+ * @param description - Description for the filename
+ * @returns Full path to the new numbered file
+ */
+export function getNextNumberedFilePath(dirPath, description) {
+    const number = getNextNumber(dirPath);
+    const filename = buildNumberedFilename(number, description);
+    return join(dirPath, filename);
+}

package/dist/shared/json-schema-mini.d.ts

@@ -0,0 +1,10 @@
+export type JsonSchemaIssue = {
+    path: string;
+    message: string;
+};
+export type JsonSchemaResult = {
+    valid: boolean;
+    errors: JsonSchemaIssue[];
+};
+export type JsonSchemaNode = Record<string, unknown>;
+export declare function validateAgainstSchema(value: unknown, schema: JsonSchemaNode): JsonSchemaResult;

package/dist/shared/json-schema-mini.js

@@ -0,0 +1,113 @@
+function joinPath(parent, segment) {
+    if (parent === '/') {
+        return `/${segment}`;
+    }
+    return `${parent}/${segment}`;
+}
+function typeOf(value) {
+    if (value === null) {
+        return 'null';
+    }
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    if (Number.isInteger(value)) {
+        return 'integer';
+    }
+    return typeof value;
+}
+function matchesType(value, expected) {
+    if (expected === 'integer') {
+        return typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value);
+    }
+    if (expected === 'number') {
+        return typeof value === 'number' && Number.isFinite(value);
+    }
+    if (expected === 'array') {
+        return Array.isArray(value);
+    }
+    if (expected === 'null') {
+        return value === null;
+    }
+    if (expected === 'object') {
+        return value !== null && typeof value === 'object' && !Array.isArray(value);
+    }
+    return typeof value === expected;
+}
+function validateNode(value, schema, path, errors) {
+    if (Array.isArray(schema.oneOf)) {
+        const branches = schema.oneOf;
+        const branchErrors = [];
+        let matched = false;
+        for (const branch of branches) {
+            const sink = [];
+            validateNode(value, branch, path, sink);
+            if (sink.length === 0) {
+                matched = true;
+                break;
+            }
+            branchErrors.push(sink);
+        }
+        if (!matched) {
+            const detail = branchErrors.map((sink) => sink.map((issue) => issue.message).join(' / ')).join(' | ');
+            errors.push({ path, message: `does not match any oneOf branch (${detail})` });
+        }
+        return;
+    }
+    const expectedType = typeof schema.type === 'string' ? schema.type : null;
+    if (expectedType !== null && !matchesType(value, expectedType)) {
+        errors.push({ path, message: `expected type ${expectedType}, got ${typeOf(value)}` });
+        return;
+    }
+    if (typeof value === 'string') {
+        if (typeof schema.minLength === 'number' && value.length < schema.minLength) {
+            errors.push({ path, message: `string shorter than minLength ${schema.minLength}` });
+        }
+        if (typeof schema.pattern === 'string' && !new RegExp(schema.pattern).test(value)) {
+            errors.push({ path, message: `string does not match pattern ${schema.pattern}` });
+        }
+        if (Array.isArray(schema.enum) && !schema.enum.includes(value)) {
+            errors.push({ path, message: `value ${JSON.stringify(value)} is not in enum` });
+        }
+        return;
+    }
+    if (typeof value === 'number') {
+        if (typeof schema.minimum === 'number' && value < schema.minimum) {
+            errors.push({ path, message: `number below minimum ${schema.minimum}` });
+        }
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (schema.items !== undefined) {
+            const itemSchema = schema.items;
+            value.forEach((entry, index) => {
+                validateNode(entry, itemSchema, joinPath(path, index), errors);
+            });
+        }
+        return;
+    }
+    if (value !== null && typeof value === 'object') {
+        const record = value;
+        if (Array.isArray(schema.required)) {
+            for (const key of schema.required) {
+                if (!Object.prototype.hasOwnProperty.call(record, key)) {
+                    errors.push({ path, message: `missing required property: ${key}` });
+                }
+            }
+        }
+        const properties = schema.properties;
+        if (properties !== null && typeof properties === 'object' && !Array.isArray(properties)) {
+            const propertyMap = properties;
+            for (const [key, child] of Object.entries(propertyMap)) {
+                if (Object.prototype.hasOwnProperty.call(record, key)) {
+                    validateNode(record[key], child, joinPath(path, key), errors);
+                }
+            }
+        }
+    }
+}
+export function validateAgainstSchema(value, schema) {
+    const errors = [];
+    validateNode(value, schema, '/', errors);
+    return { valid: errors.length === 0, errors };
+}

package/dist/shared/path-safety.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Path-safety helpers for peaks-loop artifact paths.
+ *
+ * Extracted after the v2.19.0 change-id root removal. The change-id
+ * axis was eliminated entirely; the remaining helper utilities are
+ * path-traversal / absolute-path / drive-path / UNC-path guards plus
+ * a path-containment check used by writer code.
+ *
+ * Used by services that need a "is this user-supplied path safe?"
+ * check without bringing in the change-id axis.
+ */
+export declare function isUnsafePathInput(input: string): boolean;
+export declare function isUnsafeArtifactPath(path: string): boolean;
+declare function normalizeArtifactPath(input: string): string;
+export { normalizeArtifactPath as _normalizeArtifactPath };
+/**
+ * Path-containment check. Returns true when `path` equals `artifactRoot`
+ * or starts with `<artifactRoot>/`. Used by workspace reconcile to
+ * verify on-disk paths stay inside the artifact workspace.
+ */
+export declare function isPathInsideArtifactRoot(path: string, artifactRoot: string): boolean;

package/dist/shared/path-safety.js

@@ -0,0 +1,54 @@
+/**
+ * Path-safety helpers for peaks-loop artifact paths.
+ *
+ * Extracted after the v2.19.0 change-id root removal. The change-id
+ * axis was eliminated entirely; the remaining helper utilities are
+ * path-traversal / absolute-path / drive-path / UNC-path guards plus
+ * a path-containment check used by writer code.
+ *
+ * Used by services that need a "is this user-supplied path safe?"
+ * check without bringing in the change-id axis.
+ */
+import { posix } from 'node:path';
+function normalizeForwardSlashes(input) {
+    return input.replace(/\\/g, '/');
+}
+function hasUnsafePathShape(input) {
+    const normalized = normalizeForwardSlashes(input);
+    if (input.includes('\\'))
+        return true;
+    if (!normalized || normalized === '.' || normalized === '..')
+        return true;
+    if (normalized.startsWith('/') || normalized.startsWith('//'))
+        return true;
+    if (/^[A-Za-z]:/.test(normalized))
+        return true;
+    if (normalized.includes('://'))
+        return true;
+    if (/^[^@\s]+@[^:\s]+:.+/.test(normalized))
+        return true;
+    return normalized.split('/').some((segment) => segment.length === 0 || segment === '.' || segment === '..');
+}
+export function isUnsafePathInput(input) {
+    return hasUnsafePathShape(input);
+}
+export function isUnsafeArtifactPath(path) {
+    return isUnsafePathInput(path);
+}
+function normalizeArtifactPath(input) {
+    const normalized = posix.normalize(normalizeForwardSlashes(input));
+    return normalized.replace(/\/$/, '');
+}
+export { normalizeArtifactPath as _normalizeArtifactPath };
+/**
+ * Path-containment check. Returns true when `path` equals `artifactRoot`
+ * or starts with `<artifactRoot>/`. Used by workspace reconcile to
+ * verify on-disk paths stay inside the artifact workspace.
+ */
+export function isPathInsideArtifactRoot(path, artifactRoot) {
+    if (!path || !artifactRoot)
+        return false;
+    const normalizedPath = normalizeArtifactPath(path);
+    const normalizedRoot = normalizeArtifactPath(artifactRoot);
+    return normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+}

package/dist/shared/path-utils.d.ts

@@ -0,0 +1,13 @@
+import { type Platform } from './platform.js';
+export declare const SEP: "\\" | "/";
+export declare function normalizePath(p: string): string;
+export declare function pathsEqual(a: string, b: string): boolean;
+export declare function localPath(p: string, targetPlatform?: Platform): string;
+export declare function getTempDir(options?: {
+    env?: NodeJS.ProcessEnv;
+}): string;
+export declare function isInsidePath(childPath: string, parentPath: string): boolean;
+export declare function isWindowsAbsolutePath(path: string): boolean;
+export declare function resolveInputPath(path: string): string;
+export declare function stableRealPath(path: string): string;
+export declare function stablePath(path: string): string;

package/dist/shared/path-utils.js

@@ -0,0 +1,56 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { isAbsolute, parse, relative, resolve, sep } from 'node:path';
+import { tmpdir } from 'node:os';
+import { platform } from './platform.js';
+export const SEP = sep;
+const localPathConverters = {
+    win32: (p) => p.replace(/\//g, '\\'),
+    darwin: (p) => p,
+    linux: (p) => p
+};
+export function normalizePath(p) {
+    return p.replace(/\\/g, '/');
+}
+export function pathsEqual(a, b) {
+    return normalizePath(a) === normalizePath(b);
+}
+export function localPath(p, targetPlatform = platform) {
+    return localPathConverters[targetPlatform](p);
+}
+export function getTempDir(options) {
+    const env = options?.env ?? process.env;
+    if (env.TEMP)
+        return env.TEMP;
+    if (env.TMP)
+        return env.TMP;
+    return tmpdir();
+}
+export function isInsidePath(childPath, parentPath) {
+    const relativePath = relative(parentPath, childPath);
+    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
+}
+export function isWindowsAbsolutePath(path) {
+    return /^[A-Za-z]:[\\/]/.test(path);
+}
+export function resolveInputPath(path) {
+    return isWindowsAbsolutePath(path) ? normalizePath(path) : resolve(path);
+}
+export function stableRealPath(path) {
+    return realpathSync(resolveInputPath(path));
+}
+export function stablePath(path) {
+    const resolvedPath = resolveInputPath(path);
+    if (existsSync(resolvedPath)) {
+        return stableRealPath(resolvedPath);
+    }
+    const parsedPath = parse(resolvedPath);
+    const missingSegments = [];
+    let currentPath = resolvedPath;
+    while (!existsSync(currentPath) && currentPath !== parsedPath.root) {
+        const parsedCurrent = parse(currentPath);
+        missingSegments.unshift(parsedCurrent.base);
+        currentPath = parsedCurrent.dir;
+    }
+    const realExistingPath = existsSync(currentPath) ? stableRealPath(currentPath) : parsedPath.root;
+    return resolve(realExistingPath, ...missingSegments);
+}

package/dist/shared/planner-response.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared response types for planner commands.
+ * These types ensure consistent error/status reporting across
+ * tech and RD swarm dry-run planner commands.
+ */
+export type WorkspaceUnavailableBehavior = 'preview' | 'blocked';
+export type ArtifactWorkspaceUnavailableResponse = {
+    available: false;
+    behavior: WorkspaceUnavailableBehavior;
+    reason: string;
+    nextActions: readonly string[];
+};
+export type ArtifactWorkspaceAvailableResponse<T> = {
+    available: true;
+    data: T;
+};
+export type ArtifactWorkspaceResponse<T> = ArtifactWorkspaceUnavailableResponse | ArtifactWorkspaceAvailableResponse<T>;
+export declare const WORKSPACE_UNAVAILABLE_NEXT_ACTIONS: readonly string[];
+export declare function makeUnavailableResponse(behavior: WorkspaceUnavailableBehavior, reason: string): ArtifactWorkspaceUnavailableResponse;
+export declare function makeAvailableResponse<T>(data: T): ArtifactWorkspaceAvailableResponse<T>;
+export declare function isUnavailableResponse<T>(resp: ArtifactWorkspaceResponse<T>): resp is ArtifactWorkspaceUnavailableResponse;

package/dist/shared/planner-response.js

@@ -0,0 +1,26 @@
+/**
+ * Shared response types for planner commands.
+ * These types ensure consistent error/status reporting across
+ * tech and RD swarm dry-run planner commands.
+ */
+export const WORKSPACE_UNAVAILABLE_NEXT_ACTIONS = Object.freeze([
+    'Configure a Peaks artifact workspace in your workspace config.',
+    'See peaks artifacts workspace --help for setup instructions.',
+]);
+export function makeUnavailableResponse(behavior, reason) {
+    return {
+        available: false,
+        behavior,
+        reason,
+        nextActions: [...WORKSPACE_UNAVAILABLE_NEXT_ACTIONS],
+    };
+}
+export function makeAvailableResponse(data) {
+    return {
+        available: true,
+        data,
+    };
+}
+export function isUnavailableResponse(resp) {
+    return resp.available === false;
+}

package/dist/shared/platform.d.ts

@@ -0,0 +1,6 @@
+export type Platform = 'win32' | 'darwin' | 'linux';
+export declare function detectPlatform(currentPlatform?: NodeJS.Platform): Platform;
+export declare const platform: Platform;
+export declare const isWindows: boolean;
+export declare const isMac: boolean;
+export declare const isLinux: boolean;

package/dist/shared/platform.js

@@ -0,0 +1,11 @@
+export function detectPlatform(currentPlatform = process.platform) {
+    if (currentPlatform === 'win32')
+        return 'win32';
+    if (currentPlatform === 'darwin')
+        return 'darwin';
+    return 'linux';
+}
+export const platform = detectPlatform();
+export const isWindows = platform === 'win32';
+export const isMac = platform === 'darwin';
+export const isLinux = platform === 'linux';

package/dist/shared/process.d.ts

@@ -0,0 +1,5 @@
+export type ExecCommandOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv | undefined;
+};
+export declare function execCommand(command: string, args: string[], options?: ExecCommandOptions): Promise<string>;

package/dist/shared/process.js

@@ -0,0 +1,12 @@
+import { execFile } from 'node:child_process';
+export async function execCommand(command, args, options) {
+    return new Promise((resolve, reject) => {
+        execFile(command, args, { cwd: options?.cwd, env: options?.env }, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}