opencode-synced 0.3.0 → 0.4.1

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

@@ -0,0 +1,31 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+import type { SyncConfig } from './config.js';
+export interface RepoStatus {
+    branch: string;
+    changes: string[];
+}
+export interface RepoUpdateResult {
+    updated: boolean;
+    branch: string;
+}
+type Shell = PluginInput['$'];
+export declare function isRepoCloned(repoDir: string): Promise<boolean>;
+export declare function resolveRepoIdentifier(config: SyncConfig): string;
+export declare function resolveRepoBranch(config: SyncConfig, fallback?: string): string;
+export declare function ensureRepoCloned($: Shell, config: SyncConfig, repoDir: string): Promise<void>;
+export declare function ensureRepoPrivate($: Shell, config: SyncConfig): Promise<void>;
+export declare function parseRepoVisibility(output: string): boolean;
+export declare function fetchAndFastForward($: Shell, repoDir: string, branch: string): Promise<RepoUpdateResult>;
+export declare function getRepoStatus($: Shell, repoDir: string): Promise<RepoStatus>;
+export declare function hasLocalChanges($: Shell, repoDir: string): Promise<boolean>;
+export declare function commitAll($: Shell, repoDir: string, message: string): Promise<void>;
+export declare function pushBranch($: Shell, repoDir: string, branch: string): Promise<void>;
+export declare function repoExists($: Shell, repoIdentifier: string): Promise<boolean>;
+export declare function getAuthenticatedUser($: Shell): Promise<string>;
+export interface FoundRepo {
+    owner: string;
+    name: string;
+    isPrivate: boolean;
+}
+export declare function findSyncRepo($: Shell, repoName?: string): Promise<FoundRepo | null>;
+export {};

package/dist/sync/repo.js

@@ -0,0 +1,248 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { pathExists } from './config.js';
+import { RepoDivergedError, RepoPrivateRequiredError, RepoVisibilityError, SyncCommandError, } from './errors.js';
+export async function isRepoCloned(repoDir) {
+    const gitDir = path.join(repoDir, '.git');
+    return pathExists(gitDir);
+}
+export function resolveRepoIdentifier(config) {
+    const repo = config.repo;
+    if (!repo) {
+        throw new SyncCommandError('Missing repo configuration.');
+    }
+    if (repo.url)
+        return repo.url;
+    if (repo.owner && repo.name)
+        return `${repo.owner}/${repo.name}`;
+    throw new SyncCommandError('Repo configuration must include url or owner/name.');
+}
+export function resolveRepoBranch(config, fallback = 'main') {
+    const branch = config.repo?.branch;
+    if (branch)
+        return branch;
+    return fallback;
+}
+export async function ensureRepoCloned($, config, repoDir) {
+    if (await isRepoCloned(repoDir)) {
+        return;
+    }
+    await fs.mkdir(path.dirname(repoDir), { recursive: true });
+    const repoIdentifier = resolveRepoIdentifier(config);
+    try {
+        await $ `gh repo clone ${repoIdentifier} ${repoDir}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to clone repo: ${formatError(error)}`);
+    }
+}
+export async function ensureRepoPrivate($, config) {
+    const repoIdentifier = resolveRepoIdentifier(config);
+    let output;
+    try {
+        output = await $ `gh repo view ${repoIdentifier} --json isPrivate`.quiet().text();
+    }
+    catch (error) {
+        throw new RepoVisibilityError(`Unable to verify repo visibility: ${formatError(error)}`);
+    }
+    let isPrivate = false;
+    try {
+        isPrivate = parseRepoVisibility(output);
+    }
+    catch (error) {
+        throw new RepoVisibilityError(`Unable to verify repo visibility: ${formatError(error)}`);
+    }
+    if (!isPrivate) {
+        throw new RepoPrivateRequiredError('Secrets sync requires a private GitHub repo.');
+    }
+}
+export function parseRepoVisibility(output) {
+    const parsed = JSON.parse(output);
+    if (typeof parsed.isPrivate !== 'boolean') {
+        throw new Error('Invalid repo visibility response.');
+    }
+    return parsed.isPrivate;
+}
+export async function fetchAndFastForward($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} fetch --prune`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to fetch repo: ${formatError(error)}`);
+    }
+    await checkoutBranch($, repoDir, branch);
+    const remoteRef = `origin/${branch}`;
+    const remoteExists = await hasRemoteRef($, repoDir, branch);
+    if (!remoteExists) {
+        return { updated: false, branch };
+    }
+    const { ahead, behind } = await getAheadBehind($, repoDir, remoteRef);
+    if (ahead > 0 && behind > 0) {
+        throw new RepoDivergedError(`Local sync repo has diverged. Resolve with: cd ${repoDir} && git status && git pull --rebase`);
+    }
+    if (behind > 0) {
+        try {
+            await $ `git -C ${repoDir} merge --ff-only ${remoteRef}`.quiet();
+            return { updated: true, branch };
+        }
+        catch (error) {
+            throw new SyncCommandError(`Failed to fast-forward: ${formatError(error)}`);
+        }
+    }
+    return { updated: false, branch };
+}
+export async function getRepoStatus($, repoDir) {
+    const branch = await getCurrentBranch($, repoDir);
+    const changes = await getStatusLines($, repoDir);
+    return { branch, changes };
+}
+export async function hasLocalChanges($, repoDir) {
+    const lines = await getStatusLines($, repoDir);
+    return lines.length > 0;
+}
+export async function commitAll($, repoDir, message) {
+    try {
+        await $ `git -C ${repoDir} add -A`.quiet();
+        await $ `git -C ${repoDir} commit -m ${message}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to commit changes: ${formatError(error)}`);
+    }
+}
+export async function pushBranch($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} push -u origin ${branch}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to push changes: ${formatError(error)}`);
+    }
+}
+async function getCurrentBranch($, repoDir) {
+    try {
+        const output = await $ `git -C ${repoDir} rev-parse --abbrev-ref HEAD`.quiet().text();
+        const branch = output.trim();
+        if (!branch || branch === 'HEAD')
+            return 'main';
+        return branch;
+    }
+    catch {
+        return 'main';
+    }
+}
+async function checkoutBranch($, repoDir, branch) {
+    const exists = await hasLocalBranch($, repoDir, branch);
+    try {
+        if (exists) {
+            await $ `git -C ${repoDir} checkout ${branch}`.quiet();
+            return;
+        }
+        await $ `git -C ${repoDir} checkout -b ${branch}`.quiet();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to checkout branch: ${formatError(error)}`);
+    }
+}
+async function hasLocalBranch($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} show-ref --verify refs/heads/${branch}`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasRemoteRef($, repoDir, branch) {
+    try {
+        await $ `git -C ${repoDir} show-ref --verify refs/remotes/origin/${branch}`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getAheadBehind($, repoDir, remoteRef) {
+    try {
+        const output = await $ `git -C ${repoDir} rev-list --left-right --count HEAD...${remoteRef}`
+            .quiet()
+            .text();
+        const [aheadRaw, behindRaw] = output.trim().split(/\s+/);
+        const ahead = Number(aheadRaw ?? 0);
+        const behind = Number(behindRaw ?? 0);
+        return { ahead, behind };
+    }
+    catch {
+        return { ahead: 0, behind: 0 };
+    }
+}
+async function getStatusLines($, repoDir) {
+    try {
+        const output = await $ `git -C ${repoDir} status --porcelain`.quiet().text();
+        return output
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function formatError(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export async function repoExists($, repoIdentifier) {
+    try {
+        await $ `gh repo view ${repoIdentifier} --json name`.quiet();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getAuthenticatedUser($) {
+    try {
+        const output = await $ `gh api user --jq .login`.quiet().text();
+        return output.trim();
+    }
+    catch (error) {
+        throw new SyncCommandError(`Failed to detect GitHub user. Ensure gh is authenticated: ${formatError(error)}`);
+    }
+}
+const LIKELY_SYNC_REPO_NAMES = [
+    'my-opencode-config',
+    'opencode-config',
+    'opencode-sync',
+    'opencode-synced',
+    'dotfiles-opencode',
+];
+export async function findSyncRepo($, repoName) {
+    const owner = await getAuthenticatedUser($);
+    // If user provided a specific name, check that first
+    if (repoName) {
+        const exists = await repoExists($, `${owner}/${repoName}`);
+        if (exists) {
+            const isPrivate = await checkRepoPrivate($, `${owner}/${repoName}`);
+            return { owner, name: repoName, isPrivate };
+        }
+        return null;
+    }
+    // Search through likely repo names
+    for (const name of LIKELY_SYNC_REPO_NAMES) {
+        const exists = await repoExists($, `${owner}/${name}`);
+        if (exists) {
+            const isPrivate = await checkRepoPrivate($, `${owner}/${name}`);
+            return { owner, name, isPrivate };
+        }
+    }
+    return null;
+}
+async function checkRepoPrivate($, repoIdentifier) {
+    try {
+        const output = await $ `gh repo view ${repoIdentifier} --json isPrivate`.quiet().text();
+        return parseRepoVisibility(output);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/sync/service.d.ts

@@ -0,0 +1,31 @@
+import type { PluginInput } from '@opencode-ai/plugin';
+type SyncServiceContext = Pick<PluginInput, 'client' | '$'>;
+interface InitOptions {
+    repo?: string;
+    owner?: string;
+    name?: string;
+    url?: string;
+    branch?: string;
+    includeSecrets?: boolean;
+    includeSessions?: boolean;
+    includePromptStash?: boolean;
+    create?: boolean;
+    private?: boolean;
+    extraSecretPaths?: string[];
+    localRepoPath?: string;
+}
+interface LinkOptions {
+    repo?: string;
+}
+export interface SyncService {
+    startupSync: () => Promise<void>;
+    status: () => Promise<string>;
+    init: (_options: InitOptions) => Promise<string>;
+    link: (_options: LinkOptions) => Promise<string>;
+    pull: () => Promise<string>;
+    push: () => Promise<string>;
+    enableSecrets: (_extraSecretPaths?: string[]) => Promise<string>;
+    resolve: () => Promise<string>;
+}
+export declare function createSyncService(ctx: SyncServiceContext): SyncService;
+export {};