opencode-synced 0.3.0 → 0.4.1

package/dist/sync/apply.d.ts

@@ -0,0 +1,3 @@
+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.d.ts

@@ -0,0 +1,9 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+type CommitClient = PluginInput['client'];
+type Shell = PluginInput['$'];
+interface CommitContext {
+    client: CommitClient;
+    $: Shell;
+}
+export declare function generateCommitMessage(ctx: CommitContext, repoDir: string, fallbackDate?: Date): Promise<string>;
+export {};

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

@@ -0,0 +1,35 @@
+import type { SyncLocations } from './paths.js';
+export interface SyncRepoConfig {
+    url?: string;
+    owner?: string;
+    name?: string;
+    branch?: string;
+}
+export interface SyncConfig {
+    repo?: SyncRepoConfig;
+    localRepoPath?: string;
+    includeSecrets?: boolean;
+    includeSessions?: boolean;
+    includePromptStash?: boolean;
+    extraSecretPaths?: string[];
+}
+export interface SyncState {
+    lastPull?: string;
+    lastPush?: string;
+    lastRemoteUpdate?: string;
+}
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function normalizeSyncConfig(config: SyncConfig): SyncConfig;
+export declare function loadSyncConfig(locations: SyncLocations): Promise<SyncConfig | null>;
+export declare function writeSyncConfig(locations: SyncLocations, config: SyncConfig): Promise<void>;
+export declare function loadOverrides(locations: SyncLocations): Promise<Record<string, unknown> | null>;
+export declare function loadState(locations: SyncLocations): Promise<SyncState>;
+export declare function writeState(locations: SyncLocations, state: SyncState): Promise<void>;
+export declare function applyOverridesToRuntimeConfig(config: Record<string, unknown>, overrides: Record<string, unknown>): void;
+export declare function deepMerge<T>(base: T, override: unknown): T;
+export declare function stripOverrides(localConfig: Record<string, unknown>, overrides: Record<string, unknown>, baseConfig: Record<string, unknown> | null): Record<string, unknown>;
+export declare function parseJsonc<T>(content: string): T;
+export declare function writeJsonFile(filePath: string, data: unknown, options?: {
+    jsonc: boolean;
+    mode?: number;
+}): Promise<void>;

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.d.ts

@@ -0,0 +1,19 @@
+export declare class SyncError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class SyncConfigMissingError extends SyncError {
+    constructor(message: string);
+}
+export declare class RepoDivergedError extends SyncError {
+    constructor(message: string);
+}
+export declare class RepoPrivateRequiredError extends SyncError {
+    constructor(message: string);
+}
+export declare class RepoVisibilityError extends SyncError {
+    constructor(message: string);
+}
+export declare class SyncCommandError extends SyncError {
+    constructor(message: string);
+}

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

@@ -0,0 +1,47 @@
+import type { SyncConfig } from './config.js';
+export interface XdgPaths {
+    homeDir: string;
+    configDir: string;
+    dataDir: string;
+    stateDir: string;
+}
+export interface SyncLocations {
+    xdg: XdgPaths;
+    configRoot: string;
+    syncConfigPath: string;
+    overridesPath: string;
+    statePath: string;
+    defaultRepoDir: string;
+}
+export type SyncItemType = 'file' | 'dir';
+export interface SyncItem {
+    localPath: string;
+    repoPath: string;
+    type: SyncItemType;
+    isSecret: boolean;
+    isConfigFile: boolean;
+}
+export interface ExtraSecretPlan {
+    allowlist: string[];
+    manifestPath: string;
+    entries: Array<{
+        sourcePath: string;
+        repoPath: string;
+    }>;
+}
+export interface SyncPlan {
+    items: SyncItem[];
+    extraSecrets: ExtraSecretPlan;
+    repoRoot: string;
+    homeDir: string;
+    platform: NodeJS.Platform;
+}
+export declare function resolveHomeDir(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export declare function resolveXdgPaths(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): XdgPaths;
+export declare function resolveSyncLocations(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): SyncLocations;
+export declare function expandHome(inputPath: string, homeDir: string): string;
+export declare function normalizePath(inputPath: string, homeDir: string, platform?: NodeJS.Platform): string;
+export declare function isSamePath(left: string, right: string, homeDir: string, platform?: NodeJS.Platform): boolean;
+export declare function encodeSecretPath(inputPath: string): string;
+export declare function resolveRepoRoot(config: SyncConfig | null, locations: SyncLocations): string;
+export declare function buildSyncPlan(config: SyncConfig, locations: SyncLocations, repoRoot: string, platform?: NodeJS.Platform): SyncPlan;