opencode-synced 0.4.0 → 0.4.1

package/dist/sync/apply.d.ts

@@ -1,3 +1,3 @@
-import type { SyncPlan } from './paths.ts';
+import type { SyncPlan } from './paths.js';
 export declare function syncRepoToLocal(plan: SyncPlan, overrides: Record<string, unknown> | null): Promise<void>;
 export declare function syncLocalToRepo(plan: SyncPlan, overrides: Record<string, unknown> | null): Promise<void>;

package/dist/sync/apply.js

@@ -0,0 +1,195 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { deepMerge, parseJsonc, pathExists, stripOverrides, writeJsonFile } from './config.js';
+import { normalizePath } from './paths.js';
+export async function syncRepoToLocal(plan, overrides) {
+    for (const item of plan.items) {
+        await copyItem(item.repoPath, item.localPath, item.type);
+    }
+    await applyExtraSecrets(plan, true);
+    if (overrides && Object.keys(overrides).length > 0) {
+        await applyOverridesToLocalConfig(plan, overrides);
+    }
+}
+export async function syncLocalToRepo(plan, overrides) {
+    for (const item of plan.items) {
+        if (item.isConfigFile && overrides && Object.keys(overrides).length > 0) {
+            await copyConfigForRepo(item, overrides, plan.repoRoot);
+            continue;
+        }
+        await copyItem(item.localPath, item.repoPath, item.type, true);
+    }
+    await writeExtraSecretsManifest(plan);
+}
+async function copyItem(sourcePath, destinationPath, type, removeWhenMissing = false) {
+    if (!(await pathExists(sourcePath))) {
+        if (removeWhenMissing) {
+            await removePath(destinationPath);
+        }
+        return;
+    }
+    if (type === 'file') {
+        await copyFileWithMode(sourcePath, destinationPath);
+        return;
+    }
+    await removePath(destinationPath);
+    await copyDirRecursive(sourcePath, destinationPath);
+}
+async function copyConfigForRepo(item, overrides, repoRoot) {
+    if (!(await pathExists(item.localPath))) {
+        await removePath(item.repoPath);
+        return;
+    }
+    const localContent = await fs.readFile(item.localPath, 'utf8');
+    const localConfig = parseJsonc(localContent);
+    const baseConfig = await readRepoConfig(item, repoRoot);
+    if (baseConfig) {
+        const expectedLocal = deepMerge(baseConfig, overrides);
+        if (isDeepEqual(localConfig, expectedLocal)) {
+            return;
+        }
+    }
+    const stripped = stripOverrides(localConfig, overrides, baseConfig);
+    const stat = await fs.stat(item.localPath);
+    await fs.mkdir(path.dirname(item.repoPath), { recursive: true });
+    await writeJsonFile(item.repoPath, stripped, {
+        jsonc: item.localPath.endsWith('.jsonc'),
+        mode: stat.mode & 0o777,
+    });
+}
+async function readRepoConfig(item, repoRoot) {
+    if (!item.repoPath.startsWith(repoRoot)) {
+        return null;
+    }
+    if (!(await pathExists(item.repoPath))) {
+        return null;
+    }
+    const content = await fs.readFile(item.repoPath, 'utf8');
+    return parseJsonc(content);
+}
+async function applyOverridesToLocalConfig(plan, overrides) {
+    const configFiles = plan.items.filter((item) => item.isConfigFile);
+    for (const item of configFiles) {
+        if (!(await pathExists(item.localPath)))
+            continue;
+        const content = await fs.readFile(item.localPath, 'utf8');
+        const parsed = parseJsonc(content);
+        const merged = deepMerge(parsed, overrides);
+        const stat = await fs.stat(item.localPath);
+        await writeJsonFile(item.localPath, merged, {
+            jsonc: item.localPath.endsWith('.jsonc'),
+            mode: stat.mode & 0o777,
+        });
+    }
+}
+async function copyFileWithMode(sourcePath, destinationPath) {
+    const stat = await fs.stat(sourcePath);
+    await fs.mkdir(path.dirname(destinationPath), { recursive: true });
+    await fs.copyFile(sourcePath, destinationPath);
+    await fs.chmod(destinationPath, stat.mode & 0o777);
+}
+async function copyDirRecursive(sourcePath, destinationPath) {
+    const stat = await fs.stat(sourcePath);
+    await fs.mkdir(destinationPath, { recursive: true });
+    const entries = await fs.readdir(sourcePath, { withFileTypes: true });
+    for (const entry of entries) {
+        const entrySource = path.join(sourcePath, entry.name);
+        const entryDest = path.join(destinationPath, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(entrySource, entryDest);
+            continue;
+        }
+        if (entry.isFile()) {
+            await copyFileWithMode(entrySource, entryDest);
+        }
+    }
+    await fs.chmod(destinationPath, stat.mode & 0o777);
+}
+async function removePath(targetPath) {
+    await fs.rm(targetPath, { recursive: true, force: true });
+}
+async function applyExtraSecrets(plan, fromRepo) {
+    const allowlist = plan.extraSecrets.allowlist;
+    if (allowlist.length === 0)
+        return;
+    if (!(await pathExists(plan.extraSecrets.manifestPath)))
+        return;
+    const manifestContent = await fs.readFile(plan.extraSecrets.manifestPath, 'utf8');
+    const manifest = parseJsonc(manifestContent);
+    for (const entry of manifest.entries) {
+        const normalized = normalizePath(entry.sourcePath, plan.homeDir, plan.platform);
+        const isAllowed = allowlist.includes(normalized);
+        if (!isAllowed)
+            continue;
+        const repoPath = path.isAbsolute(entry.repoPath)
+            ? entry.repoPath
+            : path.join(plan.repoRoot, entry.repoPath);
+        const localPath = entry.sourcePath;
+        if (!(await pathExists(repoPath)))
+            continue;
+        if (fromRepo) {
+            await copyFileWithMode(repoPath, localPath);
+            if (entry.mode !== undefined) {
+                await fs.chmod(localPath, entry.mode);
+            }
+        }
+    }
+}
+async function writeExtraSecretsManifest(plan) {
+    const allowlist = plan.extraSecrets.allowlist;
+    const extraDir = path.join(path.dirname(plan.extraSecrets.manifestPath), 'extra');
+    if (allowlist.length === 0) {
+        await removePath(plan.extraSecrets.manifestPath);
+        await removePath(extraDir);
+        return;
+    }
+    await removePath(extraDir);
+    const entries = [];
+    for (const entry of plan.extraSecrets.entries) {
+        const sourcePath = entry.sourcePath;
+        if (!(await pathExists(sourcePath))) {
+            continue;
+        }
+        const stat = await fs.stat(sourcePath);
+        await copyFileWithMode(sourcePath, entry.repoPath);
+        entries.push({
+            sourcePath,
+            repoPath: path.relative(plan.repoRoot, entry.repoPath),
+            mode: stat.mode & 0o777,
+        });
+    }
+    await fs.mkdir(path.dirname(plan.extraSecrets.manifestPath), { recursive: true });
+    await writeJsonFile(plan.extraSecrets.manifestPath, { entries }, { jsonc: false });
+}
+function isDeepEqual(left, right) {
+    if (left === right)
+        return true;
+    if (typeof left !== typeof right)
+        return false;
+    if (!left || !right)
+        return false;
+    if (Array.isArray(left) && Array.isArray(right)) {
+        if (left.length !== right.length)
+            return false;
+        for (let i = 0; i < left.length; i += 1) {
+            if (!isDeepEqual(left[i], right[i]))
+                return false;
+        }
+        return true;
+    }
+    if (typeof left === 'object' && typeof right === 'object') {
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        if (leftKeys.length !== rightKeys.length)
+            return false;
+        for (const key of leftKeys) {
+            if (!Object.hasOwn(right, key))
+                return false;
+            if (!isDeepEqual(left[key], right[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}

package/dist/sync/commit.js

@@ -0,0 +1,74 @@
+import { extractTextFromResponse, resolveSmallModel, unwrapData } from './utils.js';
+export async function generateCommitMessage(ctx, repoDir, fallbackDate = new Date()) {
+    const fallback = `Sync OpenCode config (${formatDate(fallbackDate)})`;
+    const diffSummary = await getDiffSummary(ctx.$, repoDir);
+    if (!diffSummary)
+        return fallback;
+    const model = await resolveSmallModel(ctx.client);
+    if (!model)
+        return fallback;
+    const prompt = [
+        'Generate a concise single-line git commit message (max 72 chars).',
+        'Focus on OpenCode config sync changes.',
+        'Return only the message, no quotes.',
+        '',
+        'Diff summary:',
+        diffSummary,
+    ].join('\n');
+    let sessionId = null;
+    try {
+        const sessionResult = await ctx.client.session.create({ body: { title: 'opencode-synced' } });
+        const session = unwrapData(sessionResult);
+        sessionId = session?.id ?? null;
+        if (!sessionId)
+            return fallback;
+        const response = await ctx.client.session.prompt({
+            path: { id: sessionId },
+            body: {
+                model,
+                parts: [{ type: 'text', text: prompt }],
+            },
+        });
+        const message = extractTextFromResponse(unwrapData(response) ?? response);
+        if (!message)
+            return fallback;
+        const sanitized = sanitizeMessage(message);
+        return sanitized || fallback;
+    }
+    catch {
+        return fallback;
+    }
+    finally {
+        if (sessionId) {
+            try {
+                await ctx.client.session.delete({ path: { id: sessionId } });
+            }
+            catch { }
+        }
+    }
+}
+function sanitizeMessage(message) {
+    const firstLine = message.split('\n')[0].trim();
+    const trimmed = firstLine.replace(/^["'`]+|["'`]+$/g, '').trim();
+    if (!trimmed)
+        return '';
+    if (trimmed.length <= 72)
+        return trimmed;
+    return trimmed.slice(0, 72).trim();
+}
+async function getDiffSummary($, repoDir) {
+    try {
+        const nameStatus = await $ `git -C ${repoDir} diff --name-status`.quiet().text();
+        const stats = await $ `git -C ${repoDir} diff --stat`.quiet().text();
+        return [nameStatus.trim(), stats.trim()].filter(Boolean).join('\n');
+    }
+    catch {
+        return '';
+    }
+}
+function formatDate(date) {
+    const year = String(date.getFullYear());
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}

package/dist/sync/config.d.ts

@@ -1,4 +1,4 @@
-import type { SyncLocations } from './paths.ts';
+import type { SyncLocations } from './paths.js';
 export interface SyncRepoConfig {
     url?: string;
     owner?: string;

package/dist/sync/config.js

@@ -0,0 +1,176 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function normalizeSyncConfig(config) {
+    return {
+        includeSecrets: Boolean(config.includeSecrets),
+        includeSessions: Boolean(config.includeSessions),
+        includePromptStash: Boolean(config.includePromptStash),
+        extraSecretPaths: Array.isArray(config.extraSecretPaths) ? config.extraSecretPaths : [],
+        localRepoPath: config.localRepoPath,
+        repo: config.repo,
+    };
+}
+export async function loadSyncConfig(locations) {
+    if (!(await pathExists(locations.syncConfigPath))) {
+        return null;
+    }
+    const content = await fs.readFile(locations.syncConfigPath, 'utf8');
+    const parsed = parseJsonc(content);
+    return normalizeSyncConfig(parsed);
+}
+export async function writeSyncConfig(locations, config) {
+    await fs.mkdir(path.dirname(locations.syncConfigPath), { recursive: true });
+    const payload = normalizeSyncConfig(config);
+    await writeJsonFile(locations.syncConfigPath, payload, { jsonc: true });
+}
+export async function loadOverrides(locations) {
+    if (!(await pathExists(locations.overridesPath))) {
+        return null;
+    }
+    const content = await fs.readFile(locations.overridesPath, 'utf8');
+    const parsed = parseJsonc(content);
+    return parsed;
+}
+export async function loadState(locations) {
+    if (!(await pathExists(locations.statePath))) {
+        return {};
+    }
+    const content = await fs.readFile(locations.statePath, 'utf8');
+    return parseJsonc(content);
+}
+export async function writeState(locations, state) {
+    await fs.mkdir(path.dirname(locations.statePath), { recursive: true });
+    await writeJsonFile(locations.statePath, state, { jsonc: false });
+}
+export function applyOverridesToRuntimeConfig(config, overrides) {
+    const merged = deepMerge(config, overrides);
+    for (const key of Object.keys(config)) {
+        delete config[key];
+    }
+    Object.assign(config, merged);
+}
+export function deepMerge(base, override) {
+    if (!isPlainObject(base) || !isPlainObject(override)) {
+        return (override === undefined ? base : override);
+    }
+    const result = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (isPlainObject(value) && isPlainObject(result[key])) {
+            result[key] = deepMerge(result[key], value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+export function stripOverrides(localConfig, overrides, baseConfig) {
+    if (!isPlainObject(localConfig) || !isPlainObject(overrides)) {
+        return localConfig;
+    }
+    const result = { ...localConfig };
+    for (const [key, overrideValue] of Object.entries(overrides)) {
+        const baseValue = baseConfig ? baseConfig[key] : undefined;
+        const currentValue = result[key];
+        if (isPlainObject(overrideValue) && isPlainObject(currentValue)) {
+            const stripped = stripOverrides(currentValue, overrideValue, isPlainObject(baseValue) ? baseValue : null);
+            if (Object.keys(stripped).length === 0 && !baseValue) {
+                delete result[key];
+            }
+            else {
+                result[key] = stripped;
+            }
+            continue;
+        }
+        if (baseValue === undefined) {
+            delete result[key];
+        }
+        else {
+            result[key] = baseValue;
+        }
+    }
+    return result;
+}
+export function parseJsonc(content) {
+    const stripped = stripJsonComments(content);
+    return JSON.parse(stripped);
+}
+export async function writeJsonFile(filePath, data, options = { jsonc: false }) {
+    const json = JSON.stringify(data, null, 2);
+    const content = options.jsonc ? `// Generated by opencode-synced\n${json}\n` : `${json}\n`;
+    await fs.writeFile(filePath, content, 'utf8');
+    if (options.mode !== undefined) {
+        await fs.chmod(filePath, options.mode);
+    }
+}
+function isPlainObject(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    return Object.getPrototypeOf(value) === Object.prototype;
+}
+function stripJsonComments(input) {
+    let output = '';
+    let inString = false;
+    let inSingleLine = false;
+    let inMultiLine = false;
+    let escapeNext = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const current = input[i];
+        const next = input[i + 1];
+        if (inSingleLine) {
+            if (current === '\n') {
+                inSingleLine = false;
+                output += current;
+            }
+            continue;
+        }
+        if (inMultiLine) {
+            if (current === '*' && next === '/') {
+                inMultiLine = false;
+                i += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            output += current;
+            if (escapeNext) {
+                escapeNext = false;
+                continue;
+            }
+            if (current === '\\') {
+                escapeNext = true;
+                continue;
+            }
+            if (current === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (current === '"' && !inString) {
+            inString = true;
+            output += current;
+            continue;
+        }
+        if (current === '/' && next === '/') {
+            inSingleLine = true;
+            i += 1;
+            continue;
+        }
+        if (current === '/' && next === '*') {
+            inMultiLine = true;
+            i += 1;
+            continue;
+        }
+        output += current;
+    }
+    return output;
+}

package/dist/sync/errors.js

@@ -0,0 +1,32 @@
+export class SyncError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class SyncConfigMissingError extends SyncError {
+    constructor(message) {
+        super('sync_config_missing', message);
+    }
+}
+export class RepoDivergedError extends SyncError {
+    constructor(message) {
+        super('repo_diverged', message);
+    }
+}
+export class RepoPrivateRequiredError extends SyncError {
+    constructor(message) {
+        super('repo_private_required', message);
+    }
+}
+export class RepoVisibilityError extends SyncError {
+    constructor(message) {
+        super('repo_visibility_error', message);
+    }
+}
+export class SyncCommandError extends SyncError {
+    constructor(message) {
+        super('sync_command_error', message);
+    }
+}

package/dist/sync/paths.d.ts

@@ -1,4 +1,4 @@
-import type { SyncConfig } from './config.ts';
+import type { SyncConfig } from './config.js';
 export interface XdgPaths {
     homeDir: string;
     configDir: string;

package/dist/sync/paths.js

@@ -0,0 +1,178 @@
+import crypto from 'node:crypto';
+import path from 'node:path';
+const DEFAULT_CONFIG_NAME = 'opencode.json';
+const DEFAULT_CONFIGC_NAME = 'opencode.jsonc';
+const DEFAULT_AGENTS_NAME = 'AGENTS.md';
+const DEFAULT_SYNC_CONFIG_NAME = 'opencode-synced.jsonc';
+const DEFAULT_OVERRIDES_NAME = 'opencode-synced.overrides.jsonc';
+const DEFAULT_STATE_NAME = 'sync-state.json';
+const CONFIG_DIRS = ['agent', 'command', 'mode', 'tool', 'themes', 'plugin'];
+const SESSION_DIRS = ['storage/session', 'storage/message', 'storage/part', 'storage/session_diff'];
+const PROMPT_STASH_FILES = ['prompt-stash.jsonl', 'prompt-history.jsonl'];
+export function resolveHomeDir(env = process.env, platform = process.platform) {
+    if (platform === 'win32') {
+        return env.USERPROFILE ?? env.HOMEDRIVE ?? env.HOME ?? '';
+    }
+    return env.HOME ?? '';
+}
+export function resolveXdgPaths(env = process.env, platform = process.platform) {
+    const homeDir = resolveHomeDir(env, platform);
+    if (!homeDir) {
+        return {
+            homeDir: '',
+            configDir: '',
+            dataDir: '',
+            stateDir: '',
+        };
+    }
+    if (platform === 'win32') {
+        const configDir = env.APPDATA ?? path.join(homeDir, 'AppData', 'Roaming');
+        const dataDir = env.LOCALAPPDATA ?? path.join(homeDir, 'AppData', 'Local');
+        // Windows doesn't have XDG_STATE_HOME equivalent, use LOCALAPPDATA
+        const stateDir = env.LOCALAPPDATA ?? path.join(homeDir, 'AppData', 'Local');
+        return { homeDir, configDir, dataDir, stateDir };
+    }
+    const configDir = env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config');
+    const dataDir = env.XDG_DATA_HOME ?? path.join(homeDir, '.local', 'share');
+    const stateDir = env.XDG_STATE_HOME ?? path.join(homeDir, '.local', 'state');
+    return { homeDir, configDir, dataDir, stateDir };
+}
+export function resolveSyncLocations(env = process.env, platform = process.platform) {
+    const xdg = resolveXdgPaths(env, platform);
+    const customConfigDir = env.OPENCODE_CONFIG_DIR;
+    const configRoot = customConfigDir
+        ? path.resolve(expandHome(customConfigDir, xdg.homeDir))
+        : path.join(xdg.configDir, 'opencode');
+    const dataRoot = path.join(xdg.dataDir, 'opencode');
+    return {
+        xdg,
+        configRoot,
+        syncConfigPath: path.join(configRoot, DEFAULT_SYNC_CONFIG_NAME),
+        overridesPath: path.join(configRoot, DEFAULT_OVERRIDES_NAME),
+        statePath: path.join(dataRoot, DEFAULT_STATE_NAME),
+        defaultRepoDir: path.join(dataRoot, 'opencode-synced', 'repo'),
+    };
+}
+export function expandHome(inputPath, homeDir) {
+    if (!inputPath)
+        return inputPath;
+    if (!homeDir)
+        return inputPath;
+    if (inputPath === '~')
+        return homeDir;
+    if (inputPath.startsWith('~/'))
+        return path.join(homeDir, inputPath.slice(2));
+    return inputPath;
+}
+export function normalizePath(inputPath, homeDir, platform = process.platform) {
+    const expanded = expandHome(inputPath, homeDir);
+    const resolved = path.resolve(expanded);
+    if (platform === 'win32') {
+        return resolved.toLowerCase();
+    }
+    return resolved;
+}
+export function isSamePath(left, right, homeDir, platform = process.platform) {
+    return normalizePath(left, homeDir, platform) === normalizePath(right, homeDir, platform);
+}
+export function encodeSecretPath(inputPath) {
+    const normalized = inputPath.replace(/\\/g, '/');
+    const safeBase = normalized.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+/, '');
+    const hash = crypto.createHash('sha1').update(normalized).digest('hex').slice(0, 8);
+    const base = safeBase ? safeBase.slice(-80) : 'secret';
+    return `${base}-${hash}`;
+}
+export function resolveRepoRoot(config, locations) {
+    if (config?.localRepoPath) {
+        return expandHome(config.localRepoPath, locations.xdg.homeDir);
+    }
+    return locations.defaultRepoDir;
+}
+export function buildSyncPlan(config, locations, repoRoot, platform = process.platform) {
+    const configRoot = locations.configRoot;
+    const dataRoot = path.join(locations.xdg.dataDir, 'opencode');
+    const repoConfigRoot = path.join(repoRoot, 'config');
+    const repoDataRoot = path.join(repoRoot, 'data');
+    const repoSecretsRoot = path.join(repoRoot, 'secrets');
+    const repoExtraDir = path.join(repoSecretsRoot, 'extra');
+    const manifestPath = path.join(repoSecretsRoot, 'extra-manifest.json');
+    const items = [];
+    const addFile = (name, isSecret, isConfigFile) => {
+        items.push({
+            localPath: path.join(configRoot, name),
+            repoPath: path.join(repoConfigRoot, name),
+            type: 'file',
+            isSecret,
+            isConfigFile,
+        });
+    };
+    addFile(DEFAULT_CONFIG_NAME, false, true);
+    addFile(DEFAULT_CONFIGC_NAME, false, true);
+    addFile(DEFAULT_AGENTS_NAME, false, false);
+    for (const dirName of CONFIG_DIRS) {
+        items.push({
+            localPath: path.join(configRoot, dirName),
+            repoPath: path.join(repoConfigRoot, dirName),
+            type: 'dir',
+            isSecret: false,
+            isConfigFile: false,
+        });
+    }
+    if (config.includeSecrets) {
+        items.push({
+            localPath: path.join(dataRoot, 'auth.json'),
+            repoPath: path.join(repoDataRoot, 'auth.json'),
+            type: 'file',
+            isSecret: true,
+            isConfigFile: false,
+        }, {
+            localPath: path.join(dataRoot, 'mcp-auth.json'),
+            repoPath: path.join(repoDataRoot, 'mcp-auth.json'),
+            type: 'file',
+            isSecret: true,
+            isConfigFile: false,
+        });
+        if (config.includeSessions) {
+            for (const dirName of SESSION_DIRS) {
+                items.push({
+                    localPath: path.join(dataRoot, dirName),
+                    repoPath: path.join(repoDataRoot, dirName),
+                    type: 'dir',
+                    isSecret: true,
+                    isConfigFile: false,
+                });
+            }
+        }
+        if (config.includePromptStash) {
+            const stateRoot = path.join(locations.xdg.stateDir, 'opencode');
+            const repoStateRoot = path.join(repoRoot, 'state');
+            for (const fileName of PROMPT_STASH_FILES) {
+                items.push({
+                    localPath: path.join(stateRoot, fileName),
+                    repoPath: path.join(repoStateRoot, fileName),
+                    type: 'file',
+                    isSecret: true,
+                    isConfigFile: false,
+                });
+            }
+        }
+    }
+    const allowlist = config.includeSecrets
+        ? (config.extraSecretPaths ?? []).map((entry) => normalizePath(entry, locations.xdg.homeDir, platform))
+        : [];
+    const entries = allowlist.map((sourcePath) => ({
+        sourcePath,
+        repoPath: path.join(repoExtraDir, encodeSecretPath(sourcePath)),
+    }));
+    return {
+        items,
+        extraSecrets: {
+            allowlist,
+            manifestPath,
+            entries,
+        },
+        repoRoot,
+        homeDir: locations.xdg.homeDir,
+        platform,
+    };
+}

package/dist/sync/repo.d.ts

@@ -1,5 +1,5 @@
 import type { PluginInput } from '@opencode-ai/plugin';
-import type { SyncConfig } from './config.ts';
+import type { SyncConfig } from './config.js';
 export interface RepoStatus {
     branch: string;
     changes: string[];