linkany 0.0.1

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <https://unlicense.org>

package/README.md

@@ -0,0 +1,156 @@
+# linkany
+
+`linkany` 是一个 **macOS/Linux** 上的“安全 symlink 管理器”，围绕一个 `manifest` 文件维护一组“source ↔ target”的链接关系，并提供四个高层 API：
+
+- `add(manifestPath, { source, target, ... })`
+- `remove(manifestPath, key, opts?)`
+- `install(manifestPath, opts?)`
+- `uninstall(manifestPath, opts?)`
+
+它的设计原则是：**安全第一、可追溯、默认拒绝任何可能导致数据丢失的行为**。
+
+## CLI（命令行）
+
+`linkany` 同时提供 **库 API** 与 **CLI**。CLI 的核心设计是：支持设置一个“全局默认 manifest”，让你后续无需重复传 `--manifest`。
+
+### 设置/查看默认 manifest
+
+- 设置默认 manifest（写入全局配置，路径会被 resolve 成绝对路径）：
+  - `linkany manifest set ./linkany.manifest.json`
+- 查看当前默认 manifest：
+  - `linkany manifest show`
+- 清空默认 manifest：
+  - `linkany manifest clear`
+
+### 在命令中使用 manifest（优先级）
+
+- **优先级**：`-m/--manifest <path>`（单次覆盖） > 全局默认 manifest
+- 示例：
+  - 使用默认 manifest：`linkany install`
+  - 单次覆盖：`linkany install -m ./other.manifest.json`
+
+### 常用命令
+
+- `linkany add --source <path> --target <path> [--kind file|dir] [--atomic|--no-atomic] [-m <manifest>] [--dry-run] [--plan]`
+- `linkany remove <key> [--keep-link] [-m <manifest>] [--dry-run] [--plan]`
+- `linkany install [-m <manifest>] [--dry-run] [--plan]`
+- `linkany uninstall [-m <manifest>] [--dry-run] [--plan]`
+
+### 全局配置文件路径（XDG）
+
+- 若设置了 `XDG_CONFIG_HOME`：`$XDG_CONFIG_HOME/linkany/config.json`
+- 否则：`~/.config/linkany/config.json`
+- 格式：
+
+```json
+{ "manifestPath": "/abs/path/to/manifest.json" }
+```
+
+## 能力概览
+
+- **仅使用 symlink**：如果 symlink 失败（权限/文件系统限制等），直接报错，不会退化为 copy 安装。
+- **文件 & 目录**：同时支持文件和目录链接。
+- **安全策略**：
+  - `add`：当 `source` 和 `target` 同时存在（且 `target` 不是指向 `source` 的 symlink）时 **拒绝**。
+  - `remove/uninstall`：只会删除 `target` 的 symlink，**绝不删除 source**。
+  - `install`：如果发现某个 `target` 存在但不是 symlink，会 **整体 abort**，避免误伤真实文件/目录。
+- **原子性（尽力而为）**：
+  - 创建/替换 symlink 时优先使用 `target.tmp.<rand>`，再 `rename` 到位。
+  - 替换已有 symlink 时会优先把旧 target 移到 `target.bak.<timestamp>.<rand>`（便于恢复）。
+- **审计记录（有记录的）**：每次调用都会把 `Result` 追加写入 JSONL 文件，默认路径为 `${manifestPath}.log.jsonl`。
+- **dry-run / plan 输出**：
+  - `opts.dryRun=true` 时不触发任何文件系统写操作（不 symlink/rename/unlink），只返回计划与结果结构。
+  - `opts.includePlanText=true` 时会在 `Result.planText` 中附带可读的 plan 文本。
+- **rollback 协议（best-effort）**：`Result.rollbackSteps` 会尽力给出“可逆步骤”的回滚计划（例如 move/symlink 的逆操作）。目前是协议与数据结构，未提供一键 rollback API。
+
+## Manifest 格式（v1）
+
+```json
+{
+  "version": 1,
+  "installs": [
+    {
+      "id": "optional-stable-id",
+      "source": "path/to/source",
+      "target": "path/to/target",
+      "kind": "file",
+      "atomic": true
+    }
+  ]
+}
+```
+
+说明：
+
+- `source/target` 支持绝对路径或相对路径；相对路径以 **manifest 文件所在目录** 为基准。
+- `id` 可选；如果没有 `id`，内部默认以 `target` 作为该条目的 identity（用于 remove）。
+- `kind` 可选：`file | dir`。不写时，`add` 会尽力推断；`install` 会从 source 的实际类型推断。
+- `atomic` 默认 `true`。
+- 允许存在额外字段（`linkany` 会尽量保留并写回）。
+
+## API
+
+### `add(manifestPath, { source, target, kind?, atomic? }, opts?)`
+
+用途：把一条映射写入 manifest，并把 `target` 收敛为指向 `source` 的 symlink。
+
+核心语义：
+
+- **source 不存在**：自动创建空 source（文件：空文件；目录：空目录）。
+- **target 已存在且不是 symlink、source 不存在**：会执行一次“安全迁移”：
+  - copy `target -> source`
+  - 将原 `target` 移到 `target.bak.<timestamp>.<rand>`
+  - 再把 `target` 改成指向 `source` 的 symlink
+- **source 与 target 同时存在**：拒绝（error），要求用户手动处理冲突。
+
+### `remove(manifestPath, key, opts?)`
+
+用途：从 manifest 移除一条映射，并且 **默认删除 target 的 symlink**。
+
+- `key`：优先匹配 `id`，否则匹配 `target`。
+- `opts.keepLink=true` 可仅移除 manifest 记录，不删除 target symlink。
+- **永远不删除 source**。
+
+### `install(manifestPath, opts?)`
+
+用途：按 manifest 全量落地，确保每个 `target` 都是指向 `source` 的 symlink。
+
+安全策略：
+
+- 任意一条出现以下情况，都会 **abort 且不做任何变更**：
+  - source 不存在
+  - target 存在但不是 symlink
+
+### `uninstall(manifestPath, opts?)`
+
+用途：按 manifest 全量撤销，只删除 `target` 的 symlink；**永远不删除 source**。
+
+## 审计日志（Audit Log）
+
+- 默认写入：`${manifestPath}.log.jsonl`
+- 每行是一条 JSON（完整 `Result`），包含：执行步骤、错误、耗时、变更摘要。
+- 可通过 `opts.auditLogPath` 指定自定义路径。
+
+## Options（opts）
+
+适用于四个 API 的通用 options（`CommonOptions`）：
+
+- `auditLogPath?: string`：覆盖默认审计日志路径。
+- `dryRun?: boolean`：只返回计划/结果，不写文件系统。
+- `includePlanText?: boolean`：在 `Result.planText` 中包含可读 plan 文本。
+- `logger?: { info/warn/error }`：注入日志实现（可选）。
+
+## 目录结构（维护者）
+
+```text
+src/
+  api/        # 4 个对外操作，分别一个文件
+  core/       # 执行引擎：plan/apply/fs/audit/runner/backup
+  manifest/   # manifest 类型与读写（写回保持未知字段）
+  cli/        # CLI 相关模块（全局配置等）
+  cli.ts      # CLI 入口（argv 解析与命令分发）
+  index.ts    # 对外统一导出
+  types.ts    # 公共类型（Result/Step/Options）
+```
+
+更详细的维护说明见 `KNOWLEDGE_BASE.md`。

package/dist/api/add.d.ts

@@ -0,0 +1,17 @@
+import { CommonOptions, LinkKind, Result } from '../types.js';
+export interface Mapping {
+    source: string;
+    target: string;
+    kind?: LinkKind;
+    atomic?: boolean;
+}
+/**
+ * add: write manifest + converge target to symlink(source).
+ *
+ * Safety rules:
+ * - If source and target both exist AND target is not already a symlink to source => reject.
+ * - If target exists and is not a symlink AND source is missing => migrate:
+ *   copy(target -> source), move original target aside to backup, then link target -> source.
+ * - If symlink creation fails => error (no copy fallback).
+ */
+export declare function add(manifestPath: string, mapping: Mapping, opts?: CommonOptions): Promise<Result>;

package/dist/api/add.js

@@ -0,0 +1,129 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { runOperation } from '../core/runner.js';
+import { planReplaceTargetWithTmp } from '../core/backup.js';
+import { detectKind, isSymlinkTo, planCopy, planEnsureSource, planUnlink, tmpPathForTarget } from '../core/plan.js';
+import { getManifestBaseDir } from '../manifest/types.js';
+import { loadOrCreateManifest, saveManifest, upsertEntry } from '../manifest/io.js';
+function mkLogger(opts) {
+    return opts?.logger;
+}
+function mkResult(operation, manifestPath) {
+    const now = new Date();
+    return {
+        ok: true,
+        operation,
+        manifestPath,
+        startedAt: now.toISOString(),
+        finishedAt: now.toISOString(),
+        durationMs: 0,
+        steps: [],
+        warnings: [],
+        errors: [],
+        changes: [],
+    };
+}
+function linkSteps(sourceAbs, targetAbs, kind, atomic) {
+    const steps = [];
+    steps.push({ kind: 'mkdirp', message: 'Ensure target parent directory exists', paths: { dir: path.dirname(targetAbs) } });
+    const tmp = atomic ? tmpPathForTarget(targetAbs) : targetAbs;
+    steps.push({ kind: 'symlink', message: atomic ? 'Create symlink at temp path' : 'Create symlink', paths: { source: sourceAbs, target: tmp, kind } });
+    if (atomic) {
+        steps.push({ kind: 'move', message: 'Atomically move temp symlink into place', paths: { from: tmp, to: targetAbs } });
+    }
+    return steps;
+}
+/**
+ * add: write manifest + converge target to symlink(source).
+ *
+ * Safety rules:
+ * - If source and target both exist AND target is not already a symlink to source => reject.
+ * - If target exists and is not a symlink AND source is missing => migrate:
+ *   copy(target -> source), move original target aside to backup, then link target -> source.
+ * - If symlink creation fails => error (no copy fallback).
+ */
+export async function add(manifestPath, mapping, opts) {
+    const baseDir = getManifestBaseDir(manifestPath);
+    const sourceAbs = path.isAbsolute(mapping.source) ? mapping.source : path.resolve(baseDir, mapping.source);
+    const targetAbs = path.isAbsolute(mapping.target) ? mapping.target : path.resolve(baseDir, mapping.target);
+    const sourceExists = await fs.pathExists(sourceAbs);
+    const targetExists = await fs.pathExists(targetAbs);
+    if (await isSymlinkTo(targetAbs, sourceAbs)) {
+        const manifest = await loadOrCreateManifest(manifestPath);
+        upsertEntry(manifest, { source: mapping.source, target: mapping.target, kind: mapping.kind, atomic: mapping.atomic });
+        await saveManifest(manifestPath, manifest);
+        return await runOperation({
+            operation: 'add',
+            manifestPath,
+            steps: [],
+            opts,
+            finalize: async (res) => {
+                res.steps.push({ kind: 'write_manifest', message: 'Update manifest', status: 'executed', paths: { file: path.resolve(manifestPath) } });
+                res.changes.push({ action: 'manifest_upsert', source: sourceAbs, target: targetAbs });
+                return res;
+            },
+        });
+    }
+    if (sourceExists && targetExists) {
+        const res = mkResult('add', manifestPath);
+        res.ok = false;
+        res.errors.push(`Refusing to proceed: source and target both exist: source=${sourceAbs} target=${targetAbs}`);
+        res.steps.push({ kind: 'noop', message: 'Safety refusal', status: 'failed', error: res.errors[0] });
+        return res;
+    }
+    let kind = mapping.kind ?? 'file';
+    if (targetExists) {
+        const st = await fs.lstat(targetAbs);
+        if (st.isSymbolicLink()) {
+            let res = mkResult('add', manifestPath);
+            res.ok = false;
+            res.errors.push(`Refusing to migrate: target is an existing symlink: ${targetAbs}`);
+            res.steps.push({ kind: 'noop', message: 'Safety refusal', status: 'failed', error: res.errors[0] });
+            return res;
+        }
+        kind = st.isDirectory() ? 'dir' : 'file';
+    }
+    else if (sourceExists) {
+        kind = await detectKind(sourceAbs);
+    }
+    const atomic = mapping.atomic ?? true;
+    const steps = [];
+    if (!sourceExists && targetExists) {
+        steps.push(...await planCopy({ fromAbs: targetAbs, toAbs: sourceAbs, kind, atomic }));
+        // Move original target to backup, then put symlink into place.
+        const { tmpAbs, steps: replaceSteps } = planReplaceTargetWithTmp({ targetAbs, atomic: true });
+        steps.push(...replaceSteps.slice(0, 1)); // move target -> backup
+        steps.push(...linkSteps(sourceAbs, targetAbs, kind, atomic)); // creates tmp + move tmp -> target
+    }
+    else {
+        steps.push(...await planEnsureSource({ sourceAbs, kind }));
+        if (targetExists) {
+            steps.push(...await planUnlink({ targetAbs }));
+        }
+        steps.push(...linkSteps(sourceAbs, targetAbs, kind, atomic));
+    }
+    const manifest = await loadOrCreateManifest(manifestPath);
+    upsertEntry(manifest, { source: mapping.source, target: mapping.target, kind: kind, atomic });
+    return await runOperation({
+        operation: 'add',
+        manifestPath,
+        steps,
+        opts,
+        finalize: async (res) => {
+            if (!res.ok)
+                return res;
+            try {
+                await saveManifest(manifestPath, manifest);
+                res.steps.push({ kind: 'write_manifest', message: 'Update manifest', status: 'executed', paths: { file: path.resolve(manifestPath) } });
+                res.changes.push({ action: 'manifest_upsert', source: sourceAbs, target: targetAbs });
+            }
+            catch (e) {
+                const msg = e?.message ? String(e.message) : String(e);
+                res.ok = false;
+                res.errors.push(`Failed to write manifest: ${msg}`);
+                res.steps.push({ kind: 'write_manifest', message: 'Update manifest', status: 'failed', error: msg, paths: { file: path.resolve(manifestPath) } });
+            }
+            return res;
+        },
+    });
+}

package/dist/api/index.d.ts

@@ -0,0 +1,4 @@
+export { add } from './add.js';
+export { remove } from './remove.js';
+export { install } from './install.js';
+export { uninstall } from './uninstall.js';

package/dist/api/index.js

@@ -0,0 +1,4 @@
+export { add } from './add.js';
+export { remove } from './remove.js';
+export { install } from './install.js';
+export { uninstall } from './uninstall.js';

package/dist/api/install.d.ts

@@ -0,0 +1,6 @@
+import { CommonOptions, Result } from '../types.js';
+/**
+ * Ensure all targets are symlinks to sources. Never mutates manifest.
+ * Safety: if any target exists and is not a symlink, abort without changes.
+ */
+export declare function install(manifestPath: string, opts?: CommonOptions): Promise<Result>;

package/dist/api/install.js

@@ -0,0 +1,88 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { planReplaceTargetWithTmp } from '../core/backup.js';
+import { runOperation } from '../core/runner.js';
+import { detectKind, isSymlinkTo, tmpPathForTarget } from '../core/plan.js';
+import { getManifestBaseDir, loadManifest, resolveEntry } from '../manifest/types.js';
+function mkLogger(opts) {
+    return opts?.logger;
+}
+function mkResult(operation, manifestPath) {
+    const now = new Date();
+    return {
+        ok: true,
+        operation,
+        manifestPath,
+        startedAt: now.toISOString(),
+        finishedAt: now.toISOString(),
+        durationMs: 0,
+        steps: [],
+        warnings: [],
+        errors: [],
+        changes: [],
+    };
+}
+function linkSteps(sourceAbs, targetAbs, kind, atomic) {
+    const steps = [];
+    steps.push({ kind: 'mkdirp', message: 'Ensure target parent directory exists', paths: { dir: path.dirname(targetAbs) } });
+    const tmp = atomic ? tmpPathForTarget(targetAbs) : targetAbs;
+    steps.push({ kind: 'symlink', message: atomic ? 'Create symlink at temp path' : 'Create symlink', paths: { source: sourceAbs, target: tmp, kind } });
+    if (atomic) {
+        steps.push({ kind: 'move', message: 'Atomically move temp symlink into place', paths: { from: tmp, to: targetAbs } });
+    }
+    return steps;
+}
+/**
+ * Ensure all targets are symlinks to sources. Never mutates manifest.
+ * Safety: if any target exists and is not a symlink, abort without changes.
+ */
+export async function install(manifestPath, opts) {
+    const logger = mkLogger(opts);
+    const result = await (async () => {
+        const manifest = await loadManifest(manifestPath);
+        const baseDir = getManifestBaseDir(manifestPath);
+        const allSteps = [];
+        for (const entry of manifest.installs) {
+            const r = resolveEntry(baseDir, entry);
+            if (!await fs.pathExists(r.sourceAbs)) {
+                const res = mkResult('install', manifestPath);
+                res.ok = false;
+                res.errors.push(`Source missing: ${r.sourceAbs}`);
+                res.steps.push({ kind: 'noop', message: 'Source missing; aborting without changes', status: 'failed', error: res.errors[0], paths: { source: r.sourceAbs } });
+                return res;
+            }
+            const targetExists = await fs.pathExists(r.targetAbs);
+            if (targetExists) {
+                const st = await fs.lstat(r.targetAbs);
+                if (!st.isSymbolicLink()) {
+                    const res = mkResult('install', manifestPath);
+                    res.ok = false;
+                    res.errors.push(`Conflict: target exists and is not a symlink: ${r.targetAbs}`);
+                    res.steps.push({ kind: 'noop', message: 'Conflict detected; aborting without changes', status: 'failed', error: res.errors[0], paths: { target: r.targetAbs } });
+                    return res;
+                }
+            }
+            const kind = r.kind ?? await detectKind(r.sourceAbs);
+            if (await isSymlinkTo(r.targetAbs, r.sourceAbs))
+                continue;
+            if (targetExists) {
+                // Stronger atomic replace: move old target aside to backup, then replace with tmp.
+                if (r.atomic) {
+                    const { steps: replaceSteps } = planReplaceTargetWithTmp({ targetAbs: r.targetAbs, atomic: true });
+                    allSteps.push(...replaceSteps.slice(0, 1)); // move target -> backup
+                }
+                else {
+                    allSteps.push({ kind: 'unlink', message: 'Remove existing target symlink before linking', paths: { target: r.targetAbs } });
+                }
+            }
+            allSteps.push(...linkSteps(r.sourceAbs, r.targetAbs, kind, r.atomic));
+        }
+        return await runOperation({
+            operation: 'install',
+            manifestPath,
+            steps: allSteps,
+            opts,
+        });
+    })();
+    return result;
+}

package/dist/api/remove.d.ts

@@ -0,0 +1,12 @@
+import { CommonOptions, Result } from '../types.js';
+export interface RemoveOptions extends CommonOptions {
+    /**
+     * Default: false. If true, do NOT delete the target link.
+     */
+    keepLink?: boolean;
+}
+/**
+ * remove: remove an entry from manifest, and by default delete the target symlink.
+ * Never deletes sources.
+ */
+export declare function remove(manifestPath: string, key: string, opts?: RemoveOptions): Promise<Result>;

package/dist/api/remove.js

@@ -0,0 +1,62 @@
+import path from 'path';
+import { runOperation } from '../core/runner.js';
+import { planUnlink } from '../core/plan.js';
+import { getManifestBaseDir, loadManifest, resolveEntry } from '../manifest/types.js';
+import { removeEntry, saveManifest } from '../manifest/io.js';
+function mkLogger(opts) {
+    return opts?.logger;
+}
+/**
+ * remove: remove an entry from manifest, and by default delete the target symlink.
+ * Never deletes sources.
+ */
+export async function remove(manifestPath, key, opts) {
+    const manifest = await loadManifest(manifestPath);
+    const baseDir = getManifestBaseDir(manifestPath);
+    const entry = manifest.installs.find(e => (e.id && e.id === key) || e.target === key || (e.id || e.target) === key);
+    if (!entry) {
+        return {
+            ok: false,
+            operation: 'remove',
+            manifestPath,
+            startedAt: new Date().toISOString(),
+            finishedAt: new Date().toISOString(),
+            durationMs: 0,
+            steps: [],
+            warnings: [],
+            errors: [`Entry not found in manifest: ${key}`],
+            changes: [],
+        };
+    }
+    const r = resolveEntry(baseDir, entry);
+    const steps = [];
+    if (!opts?.keepLink) {
+        steps.push(...await planUnlink({ targetAbs: r.targetAbs }));
+    }
+    else {
+        steps.push({ kind: 'noop', message: 'keepLink=true; not unlinking target', status: 'skipped', paths: { target: r.targetAbs } });
+    }
+    return await runOperation({
+        operation: 'remove',
+        manifestPath,
+        steps,
+        opts,
+        finalize: async (res) => {
+            if (!res.ok)
+                return res;
+            removeEntry(manifest, entry.id || entry.target);
+            try {
+                await saveManifest(manifestPath, manifest);
+                res.steps.push({ kind: 'write_manifest', message: 'Update manifest', status: 'executed', paths: { file: path.resolve(manifestPath) } });
+                res.changes.push({ action: 'manifest_remove', target: r.targetAbs });
+            }
+            catch (e) {
+                const msg = e?.message ? String(e.message) : String(e);
+                res.ok = false;
+                res.errors.push(`Failed to write manifest: ${msg}`);
+                res.steps.push({ kind: 'write_manifest', message: 'Update manifest', status: 'failed', error: msg, paths: { file: path.resolve(manifestPath) } });
+            }
+            return res;
+        },
+    });
+}

package/dist/api/uninstall.d.ts

@@ -0,0 +1,5 @@
+import { CommonOptions, Result } from '../types.js';
+/**
+ * Remove all target symlinks listed in manifest. Never deletes sources.
+ */
+export declare function uninstall(manifestPath: string, opts?: CommonOptions): Promise<Result>;

package/dist/api/uninstall.js

@@ -0,0 +1,24 @@
+import { runOperation } from '../core/runner.js';
+import { planUnlink } from '../core/plan.js';
+import { getManifestBaseDir, loadManifest, resolveEntry } from '../manifest/types.js';
+function mkLogger(opts) {
+    return opts?.logger;
+}
+/**
+ * Remove all target symlinks listed in manifest. Never deletes sources.
+ */
+export async function uninstall(manifestPath, opts) {
+    const manifest = await loadManifest(manifestPath);
+    const baseDir = getManifestBaseDir(manifestPath);
+    const allSteps = [];
+    for (const entry of manifest.installs) {
+        const r = resolveEntry(baseDir, entry);
+        allSteps.push(...await planUnlink({ targetAbs: r.targetAbs }));
+    }
+    return await runOperation({
+        operation: 'uninstall',
+        manifestPath,
+        steps: allSteps,
+        opts,
+    });
+}

package/dist/cli/config.d.ts

@@ -0,0 +1,16 @@
+export interface LinkanyConfig {
+    manifestPath?: string;
+}
+export interface ConfigEnv {
+    env?: NodeJS.ProcessEnv;
+    /**
+     * For tests or embedding, override home dir (default: os.homedir()).
+     */
+    homeDir?: string;
+}
+export declare function getGlobalConfigPath(opts?: ConfigEnv): string;
+export declare function readGlobalConfig(opts?: ConfigEnv): Promise<LinkanyConfig>;
+export declare function writeGlobalConfig(config: LinkanyConfig, opts?: ConfigEnv): Promise<void>;
+export declare function setDefaultManifestPath(manifestPath: string, opts?: ConfigEnv): Promise<string>;
+export declare function getDefaultManifestPath(opts?: ConfigEnv): Promise<string | undefined>;
+export declare function clearDefaultManifestPath(opts?: ConfigEnv): Promise<void>;

package/dist/cli/config.js

@@ -0,0 +1,38 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+export function getGlobalConfigPath(opts = {}) {
+    const env = opts.env ?? process.env;
+    const base = env.XDG_CONFIG_HOME || path.join(opts.homeDir ?? os.homedir(), '.config');
+    return path.join(base, 'linkany', 'config.json');
+}
+export async function readGlobalConfig(opts = {}) {
+    const p = getGlobalConfigPath(opts);
+    if (!await fs.pathExists(p))
+        return {};
+    const json = await fs.readJson(p);
+    if (!json || typeof json !== 'object')
+        return {};
+    const manifestPath = json.manifestPath;
+    return typeof manifestPath === 'string' ? { manifestPath } : {};
+}
+export async function writeGlobalConfig(config, opts = {}) {
+    const p = getGlobalConfigPath(opts);
+    await fs.ensureDir(path.dirname(p));
+    await fs.writeJson(p, config, { spaces: 2 });
+}
+export async function setDefaultManifestPath(manifestPath, opts = {}) {
+    const abs = path.resolve(manifestPath);
+    await writeGlobalConfig({ manifestPath: abs }, opts);
+    return abs;
+}
+export async function getDefaultManifestPath(opts = {}) {
+    const cfg = await readGlobalConfig(opts);
+    return cfg.manifestPath;
+}
+export async function clearDefaultManifestPath(opts = {}) {
+    const p = getGlobalConfigPath(opts);
+    if (!await fs.pathExists(p))
+        return;
+    await fs.remove(p);
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function main(argv?: string[]): Promise<number>;