jkunz
6f32a206b4
Keeps provider credentials local while executing OpenCode shell and file tools against the selected remote workspace over SSH.
627 lines
32 KiB
TypeScript
627 lines
32 KiB
TypeScript
import {
|
|
gitZoneIdeProtocolVersion,
|
|
type IRemoteServerManifest,
|
|
type IRemoteServerPaths,
|
|
} from '@git.zone/ide-protocol';
|
|
|
|
export interface IRemoteServerInstallPlanOptions {
|
|
serverVersion: string;
|
|
artifactName: string;
|
|
installRoot?: string;
|
|
platform?: string;
|
|
arch?: string;
|
|
sha256?: string;
|
|
protocolVersion?: number;
|
|
createdAt?: string;
|
|
}
|
|
|
|
export interface IRemoteServerInstallPlan {
|
|
manifest: IRemoteServerManifest;
|
|
paths: IRemoteServerPaths;
|
|
markerFile: string;
|
|
}
|
|
|
|
export interface IRemoteServerBootstrapOptions {
|
|
serverVersion: string;
|
|
workspacePath: string;
|
|
theiaPort: number;
|
|
opencodePort: number;
|
|
opencodeUsername: string;
|
|
opencodePassword: string;
|
|
installRoot?: string;
|
|
nodeEnv?: string;
|
|
theiaColorTheme?: string;
|
|
}
|
|
|
|
export interface IRemoteEphemeralBootstrapOptions extends IRemoteServerBootstrapOptions {
|
|
runtimeRoot: string;
|
|
ideDataRoot?: string;
|
|
nodePath?: string;
|
|
}
|
|
|
|
export interface IRemoteEphemeralReadinessOptions {
|
|
runtimeRoot: string;
|
|
theiaPort: number;
|
|
ideDataRoot?: string;
|
|
nodePath?: string;
|
|
waitSeconds?: number;
|
|
}
|
|
|
|
export interface IRemoteEphemeralRuntimeCacheCheckOptions {
|
|
runtimeRoot: string;
|
|
runtimeSha256: string;
|
|
markerFileName?: string;
|
|
nodePath?: string;
|
|
}
|
|
|
|
export interface IRemoteEphemeralRuntimeMarkOptions {
|
|
runtimeRoot: string;
|
|
runtimeSha256: string;
|
|
markerFileName?: string;
|
|
nodePath?: string;
|
|
}
|
|
|
|
export interface IRemoteEphemeralPortAllocationOptions {
|
|
runtimeRoot: string;
|
|
count?: number;
|
|
nodePath?: string;
|
|
}
|
|
|
|
export interface IRemoteProjectRegistryOptions {
|
|
runtimeRoot: string;
|
|
ideDataRoot?: string;
|
|
nodePath?: string;
|
|
}
|
|
|
|
export interface IRemoteProjectUpsertOptions extends IRemoteProjectRegistryOptions {
|
|
projectPath: string;
|
|
title?: string;
|
|
}
|
|
|
|
export interface IRemoteOpenCodeToolCommandOptions {
|
|
runtimeRoot: string;
|
|
workspacePath: string;
|
|
toolName: string;
|
|
nodePath?: string;
|
|
rgPath?: string;
|
|
}
|
|
|
|
export const defaultIdeDataRoot = '~/.git.zone/ide';
|
|
export const defaultInstallRoot = '~/.git.zone/ide/server';
|
|
export const remoteEphemeralRuntimeMarkerFileName = '.gitzone-runtime-sha256';
|
|
export const remoteProjectsFileName = 'projects.json';
|
|
export const defaultTheiaColorTheme = 'dark';
|
|
|
|
export const createRemoteServerInstallPlan = (
|
|
options: IRemoteServerInstallPlanOptions,
|
|
): IRemoteServerInstallPlan => {
|
|
const installRoot = trimTrailingSlash(options.installRoot ?? defaultInstallRoot);
|
|
const versionRoot = joinRemotePath(installRoot, options.serverVersion);
|
|
const paths: IRemoteServerPaths = {
|
|
installRoot,
|
|
versionRoot,
|
|
currentLink: joinRemotePath(installRoot, 'current'),
|
|
logsDir: joinRemotePath(installRoot, 'logs'),
|
|
manifestPath: joinRemotePath(versionRoot, 'manifest.json'),
|
|
};
|
|
|
|
return {
|
|
manifest: createRemoteServerManifest(options),
|
|
paths,
|
|
markerFile: joinRemotePath(versionRoot, '.installed'),
|
|
};
|
|
};
|
|
|
|
export const createRemoteServerManifest = (
|
|
options: IRemoteServerInstallPlanOptions,
|
|
): IRemoteServerManifest => ({
|
|
protocolVersion: options.protocolVersion ?? gitZoneIdeProtocolVersion,
|
|
serverVersion: options.serverVersion,
|
|
platform: options.platform ?? 'unknown',
|
|
arch: options.arch ?? 'unknown',
|
|
artifactName: options.artifactName,
|
|
sha256: options.sha256,
|
|
createdAt: options.createdAt ?? new Date().toISOString(),
|
|
});
|
|
|
|
export const createRemoteInstallCommand = (plan: IRemoteServerInstallPlan) => {
|
|
const manifestJson = JSON.stringify(plan.manifest, undefined, 2);
|
|
return [
|
|
'set -euo pipefail',
|
|
`mkdir -p ${quoteRemotePath(plan.paths.versionRoot)} ${quoteRemotePath(plan.paths.logsDir)}`,
|
|
`cat > ${quoteRemotePath(plan.paths.manifestPath)} <<'GITZONE_IDE_MANIFEST'`,
|
|
manifestJson,
|
|
'GITZONE_IDE_MANIFEST',
|
|
`ln -sfn ${quoteRemotePath(plan.paths.versionRoot)} ${quoteRemotePath(plan.paths.currentLink)}`,
|
|
`touch ${quoteRemotePath(plan.markerFile)}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteBootstrapCommand = (options: IRemoteServerBootstrapOptions) => {
|
|
const plan = createRemoteServerInstallPlan({
|
|
serverVersion: options.serverVersion,
|
|
artifactName: 'remote-theia',
|
|
installRoot: options.installRoot,
|
|
});
|
|
const appDir = joinRemotePath(plan.paths.versionRoot, 'applications/remote-theia');
|
|
const logFile = joinRemotePath(plan.paths.logsDir, `theia-${options.theiaPort}.log`);
|
|
const env = {
|
|
GITZONE_IDE_WORKSPACE: options.workspacePath,
|
|
GITZONE_IDE_OPENCODE_PORT: `${options.opencodePort}`,
|
|
GITZONE_IDE_DISABLE_OPENCODE_AUTOSTART: '1',
|
|
OPENCODE_SERVER_USERNAME: options.opencodeUsername,
|
|
OPENCODE_SERVER_PASSWORD: options.opencodePassword,
|
|
NODE_ENV: options.nodeEnv ?? 'production',
|
|
} satisfies Record<string, string>;
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`mkdir -p ${quoteRemotePath(plan.paths.logsDir)}`,
|
|
`test -d ${quoteRemotePath(options.workspacePath)} || { printf 'workspace path not found: %s\n' ${quoteShellArg(options.workspacePath)} >&2; exit 1; }`,
|
|
`test -d ${quoteRemotePath(appDir)} || { printf 'remote Theia app not installed: %s\n' ${quoteShellArg(appDir)} >&2; exit 1; }`,
|
|
'command -v pnpm >/dev/null || { printf \'pnpm not found on remote host\n\' >&2; exit 1; }',
|
|
`cd ${quoteRemotePath(options.workspacePath)}`,
|
|
...Object.entries(env).map(([key, value]) => {
|
|
const renderedValue = key === 'GITZONE_IDE_WORKSPACE' ? quoteRemotePath(value) : quoteShellArg(value);
|
|
return `export ${key}=${renderedValue}`;
|
|
}),
|
|
`nohup pnpm --dir ${quoteRemotePath(appDir)} start --hostname 127.0.0.1 --port ${options.theiaPort} ${quoteRemotePath(options.workspacePath)} > ${quoteRemotePath(logFile)} 2>&1 < /dev/null &`,
|
|
`printf 'theiaPort=%s\\n' ${options.theiaPort}`,
|
|
`printf 'opencodePort=%s\\n' ${options.opencodePort}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteEphemeralBootstrapCommand = (options: IRemoteEphemeralBootstrapOptions) => {
|
|
const appDir = joinRemotePath(options.runtimeRoot, 'applications/remote-theia');
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const ideDataRoot = options.ideDataRoot ?? defaultIdeDataRoot;
|
|
const logsDir = joinRemotePath(ideDataRoot, 'logs');
|
|
const theiaConfigDir = joinRemotePath(ideDataRoot, 'theia');
|
|
const theiaSettingsPath = joinRemotePath(theiaConfigDir, 'settings.json');
|
|
const logFile = joinRemotePath(logsDir, `theia-${options.theiaPort}.log`);
|
|
const theiaColorTheme = options.theiaColorTheme ?? defaultTheiaColorTheme;
|
|
const themePreferenceScript = [
|
|
"const fs = require('fs');",
|
|
'const settingsPath = process.env.GITZONE_IDE_THEIA_SETTINGS;',
|
|
'const colorTheme = process.env.GITZONE_IDE_THEIA_COLOR_THEME;',
|
|
'let settings = {};',
|
|
'try {',
|
|
" const raw = fs.readFileSync(settingsPath, 'utf8').trim();",
|
|
' settings = raw ? JSON.parse(raw) : {};',
|
|
'} catch (error) {',
|
|
" if (!error || error.code !== 'ENOENT') throw error;",
|
|
'}',
|
|
"settings['workbench.colorTheme'] = colorTheme;",
|
|
"fs.writeFileSync(settingsPath, `${JSON.stringify(settings, undefined, 2)}\\n`);",
|
|
].join('\n');
|
|
const env = {
|
|
GITZONE_IDE_WORKSPACE: options.workspacePath,
|
|
GITZONE_IDE_OPENCODE_PORT: `${options.opencodePort}`,
|
|
GITZONE_IDE_DISABLE_OPENCODE_AUTOSTART: '1',
|
|
OPENCODE_SERVER_USERNAME: options.opencodeUsername,
|
|
OPENCODE_SERVER_PASSWORD: options.opencodePassword,
|
|
NODE_ENV: options.nodeEnv ?? 'production',
|
|
} satisfies Record<string, string>;
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`mkdir -p ${quoteRemotePath(logsDir)} ${quoteRemotePath(theiaConfigDir)}`,
|
|
`export LD_LIBRARY_PATH=${quoteRemotePath(joinRemotePath(options.runtimeRoot, 'node/lib'))}:\${LD_LIBRARY_PATH:-}`,
|
|
`test -x ${quoteRemotePath(nodePath)} || { printf 'bundled node not executable: %s\n' ${quoteShellArg(nodePath)} >&2; exit 1; }`,
|
|
`test -f ${quoteRemotePath(joinRemotePath(appDir, 'lib/backend/main.js'))} || { printf 'bundled Theia backend missing: %s\n' ${quoteShellArg(appDir)} >&2; exit 1; }`,
|
|
`test -d ${quoteRemotePath(options.workspacePath)} || { printf 'workspace path not found: %s\n' ${quoteShellArg(options.workspacePath)} >&2; exit 1; }`,
|
|
`GITZONE_IDE_THEIA_SETTINGS=${quoteRemotePath(theiaSettingsPath)} GITZONE_IDE_THEIA_COLOR_THEME=${quoteShellArg(theiaColorTheme)} ${quoteRemotePath(nodePath)} <<'GITZONE_IDE_THEME'`,
|
|
themePreferenceScript,
|
|
'GITZONE_IDE_THEME',
|
|
`cd ${quoteRemotePath(options.workspacePath)}`,
|
|
`export THEIA_CONFIG_DIR=${quoteRemotePath(theiaConfigDir)}`,
|
|
...Object.entries(env).map(([key, value]) => {
|
|
const renderedValue = key === 'GITZONE_IDE_WORKSPACE' ? quoteRemotePath(value) : quoteShellArg(value);
|
|
return `export ${key}=${renderedValue}`;
|
|
}),
|
|
`nohup ${quoteRemotePath(nodePath)} ${quoteRemotePath(joinRemotePath(appDir, 'lib/backend/main.js'))} --hostname 127.0.0.1 --port ${options.theiaPort} ${quoteRemotePath(options.workspacePath)} > ${quoteRemotePath(logFile)} 2>&1 < /dev/null &`,
|
|
`printf 'runtimeRoot=%s\n' ${quoteShellArg(options.runtimeRoot)}`,
|
|
`printf 'theiaPort=%s\n' ${options.theiaPort}`,
|
|
`printf 'opencodePort=%s\n' ${options.opencodePort}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteEphemeralReadinessCommand = (options: IRemoteEphemeralReadinessOptions) => {
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const ideDataRoot = options.ideDataRoot ?? defaultIdeDataRoot;
|
|
const logFile = joinRemotePath(ideDataRoot, 'logs', `theia-${options.theiaPort}.log`);
|
|
const waitSeconds = options.waitSeconds ?? 30;
|
|
const probeScript = `fetch('http://127.0.0.1:${options.theiaPort}/').then((response) => process.exit(response.ok ? 0 : 1)).catch(() => process.exit(1))`;
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`export LD_LIBRARY_PATH=${quoteRemotePath(joinRemotePath(options.runtimeRoot, 'node/lib'))}:\${LD_LIBRARY_PATH:-}`,
|
|
`for attempt in $(seq 1 ${waitSeconds}); do`,
|
|
` if ${quoteRemotePath(nodePath)} -e ${quoteShellArg(probeScript)} >/dev/null 2>&1; then`,
|
|
` printf 'theiaReady=%s\n' ${options.theiaPort}`,
|
|
' exit 0',
|
|
' fi',
|
|
' sleep 1',
|
|
'done',
|
|
`printf 'remote Theia did not become ready on port %s\n' ${options.theiaPort} >&2`,
|
|
`if test -f ${quoteRemotePath(logFile)}; then sed -n '1,200p' ${quoteRemotePath(logFile)} >&2; fi`,
|
|
'exit 1',
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteEphemeralRuntimeCacheCheckCommand = (options: IRemoteEphemeralRuntimeCacheCheckOptions) => {
|
|
const markerFileName = options.markerFileName ?? remoteEphemeralRuntimeMarkerFileName;
|
|
const markerPath = joinRemotePath(options.runtimeRoot, markerFileName);
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const backendPath = joinRemotePath(options.runtimeRoot, 'applications/remote-theia/lib/backend/main.js');
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`test -f ${quoteRemotePath(markerPath)}`,
|
|
`test "$(cat ${quoteRemotePath(markerPath)})" = ${quoteShellArg(options.runtimeSha256)}`,
|
|
`test -x ${quoteRemotePath(nodePath)}`,
|
|
`test -f ${quoteRemotePath(backendPath)}`,
|
|
`printf 'runtimeCache=hit\n'`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteEphemeralRuntimeMarkCommand = (options: IRemoteEphemeralRuntimeMarkOptions) => {
|
|
const markerFileName = options.markerFileName ?? remoteEphemeralRuntimeMarkerFileName;
|
|
const markerPath = joinRemotePath(options.runtimeRoot, markerFileName);
|
|
const markerTempPath = `${markerPath}.tmp`;
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const backendPath = joinRemotePath(options.runtimeRoot, 'applications/remote-theia/lib/backend/main.js');
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`test -x ${quoteRemotePath(nodePath)}`,
|
|
`test -f ${quoteRemotePath(backendPath)}`,
|
|
`printf '%s\n' ${quoteShellArg(options.runtimeSha256)} > ${quoteRemotePath(markerTempPath)}`,
|
|
`mv ${quoteRemotePath(markerTempPath)} ${quoteRemotePath(markerPath)}`,
|
|
`printf 'runtimeCache=stored\n'`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteEphemeralPortAllocationCommand = (options: IRemoteEphemeralPortAllocationOptions) => {
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const count = options.count ?? 1;
|
|
const script = [
|
|
"const net = require('net');",
|
|
`const count = ${JSON.stringify(count)};`,
|
|
'const ports = [];',
|
|
'const servers = [];',
|
|
'const listen = () => new Promise((resolve, reject) => {',
|
|
' const server = net.createServer();',
|
|
" server.on('error', reject);",
|
|
" server.listen(0, '127.0.0.1', () => {",
|
|
' ports.push(server.address().port);',
|
|
' servers.push(server);',
|
|
' resolve();',
|
|
' });',
|
|
'});',
|
|
'(async () => {',
|
|
' for (let index = 0; index < count; index++) await listen();',
|
|
" console.log(`ports=${ports.join(',')}`);",
|
|
' await Promise.all(servers.map((server) => new Promise((resolve) => server.close(resolve))));',
|
|
'})().catch((error) => { console.error(error.stack || String(error)); process.exit(1); });',
|
|
].join('\n');
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`export LD_LIBRARY_PATH=${quoteRemotePath(joinRemotePath(options.runtimeRoot, 'node/lib'))}:\${LD_LIBRARY_PATH:-}`,
|
|
`${quoteRemotePath(nodePath)} -e ${quoteShellArg(script)}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteOpenCodeToolCommand = (options: IRemoteOpenCodeToolCommandOptions) => {
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const rgPath = options.rgPath ?? joinRemotePath(options.runtimeRoot, 'applications/remote-theia/lib/backend/native/rg');
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`export LD_LIBRARY_PATH=${quoteRemotePath(joinRemotePath(options.runtimeRoot, 'node/lib'))}:\${LD_LIBRARY_PATH:-}`,
|
|
`export GITZONE_IDE_WORKSPACE=${quoteRemotePath(options.workspacePath)}`,
|
|
`export GITZONE_IDE_TOOL_NAME=${quoteShellArg(options.toolName)}`,
|
|
`export GITZONE_IDE_RG_PATH=${quoteRemotePath(rgPath)}`,
|
|
`${quoteRemotePath(nodePath)} -e ${quoteShellArg(remoteOpenCodeToolScript)}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteProjectListCommand = (options: IRemoteProjectRegistryOptions) => {
|
|
const projectsFile = joinRemotePath(options.ideDataRoot ?? defaultIdeDataRoot, remoteProjectsFileName);
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`if test -f ${quoteRemotePath(projectsFile)}; then`,
|
|
` cat ${quoteRemotePath(projectsFile)}`,
|
|
'else',
|
|
" printf '{\"projects\":[]}\n'",
|
|
'fi',
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteProjectUpsertCommand = (options: IRemoteProjectUpsertOptions) => {
|
|
const ideDataRoot = options.ideDataRoot ?? defaultIdeDataRoot;
|
|
const projectsFile = joinRemotePath(ideDataRoot, remoteProjectsFileName);
|
|
const nodePath = options.nodePath ?? joinRemotePath(options.runtimeRoot, 'node/bin/node');
|
|
const script = [
|
|
"const crypto = require('crypto');",
|
|
"const fs = require('fs');",
|
|
"const path = require('path');",
|
|
'const projectsFile = process.env.GITZONE_IDE_PROJECTS_FILE;',
|
|
'const projectPath = process.env.GITZONE_IDE_PROJECT_PATH;',
|
|
'const title = process.env.GITZONE_IDE_PROJECT_TITLE || path.basename(projectPath) || projectPath;',
|
|
"let registry = { projects: [] };",
|
|
"try { registry = JSON.parse(fs.readFileSync(projectsFile, 'utf8')); } catch {}",
|
|
"if (!Array.isArray(registry.projects)) registry.projects = [];",
|
|
"const id = crypto.createHash('sha256').update(projectPath).digest('hex').slice(0, 16);",
|
|
'const now = new Date().toISOString();',
|
|
'const existing = registry.projects.find((project) => project.id === id || project.path === projectPath);',
|
|
'if (existing) {',
|
|
' existing.id = id;',
|
|
' existing.path = projectPath;',
|
|
' existing.title = title;',
|
|
' existing.updatedAt = now;',
|
|
'} else {',
|
|
' registry.projects.push({ id, path: projectPath, title, createdAt: now, updatedAt: now });',
|
|
'}',
|
|
'registry.projects.sort((left, right) => left.title.localeCompare(right.title));',
|
|
'fs.mkdirSync(path.dirname(projectsFile), { recursive: true });',
|
|
"fs.writeFileSync(`${projectsFile}.tmp`, `${JSON.stringify(registry, undefined, 2)}\\n`);",
|
|
"fs.renameSync(`${projectsFile}.tmp`, projectsFile);",
|
|
'console.log(JSON.stringify(registry));',
|
|
].join('\n');
|
|
|
|
return [
|
|
'set -euo pipefail',
|
|
`export GITZONE_IDE_PROJECTS_FILE=${quoteRemotePath(projectsFile)}`,
|
|
`export GITZONE_IDE_PROJECT_PATH=${quoteRemotePath(options.projectPath)}`,
|
|
`export GITZONE_IDE_PROJECT_TITLE=${quoteShellArg(options.title ?? '')}`,
|
|
`test -d "$GITZONE_IDE_PROJECT_PATH" || { printf 'workspace path not found: %s\n' "$GITZONE_IDE_PROJECT_PATH" >&2; exit 1; }`,
|
|
`export LD_LIBRARY_PATH=${quoteRemotePath(joinRemotePath(options.runtimeRoot, 'node/lib'))}:\${LD_LIBRARY_PATH:-}`,
|
|
`${quoteRemotePath(nodePath)} -e ${quoteShellArg(script)}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const createRemoteHealthCommand = (serverVersion: string, installRoot = defaultInstallRoot) => {
|
|
const plan = createRemoteServerInstallPlan({
|
|
serverVersion,
|
|
artifactName: 'remote-theia',
|
|
installRoot,
|
|
});
|
|
return [
|
|
'set -euo pipefail',
|
|
`test -f ${quoteRemotePath(plan.markerFile)}`,
|
|
`cat ${quoteRemotePath(plan.paths.manifestPath)}`,
|
|
].join('\n');
|
|
};
|
|
|
|
export const remoteOpenCodeToolScript = [
|
|
"const fs = require('fs');",
|
|
"const path = require('path');",
|
|
"const childProcess = require('child_process');",
|
|
"const toolName = process.env.GITZONE_IDE_TOOL_NAME;",
|
|
"const workspacePath = expandHome(process.env.GITZONE_IDE_WORKSPACE || process.cwd());",
|
|
"const rgPath = process.env.GITZONE_IDE_RG_PATH || 'rg';",
|
|
"const inputText = fs.readFileSync(0, 'utf8');",
|
|
"const request = inputText.trim() ? JSON.parse(inputText) : {};",
|
|
"const args = request.args || {};",
|
|
"const MAX_LINES = 2000;",
|
|
"const MAX_LINE_LENGTH = 2000;",
|
|
"const MAX_BYTES = 50 * 1024;",
|
|
"function expandHome(value) {",
|
|
" const text = String(value || '');",
|
|
" if (text === '~' || text === '$HOME') return process.env.HOME || text;",
|
|
" if (text.startsWith('~/')) return path.join(process.env.HOME || '', text.slice(2));",
|
|
" if (text.startsWith('$HOME/')) return path.join(process.env.HOME || '', text.slice(6));",
|
|
" return text;",
|
|
"}",
|
|
"function normalizeRemotePath(value, fallback) {",
|
|
" if (!value) return fallback;",
|
|
" const expanded = expandHome(value);",
|
|
" return path.isAbsolute(expanded) ? path.normalize(expanded) : path.resolve(fallback, expanded);",
|
|
"}",
|
|
"function limitLine(line) {",
|
|
" return line.length > MAX_LINE_LENGTH ? line.slice(0, MAX_LINE_LENGTH) + '... (line truncated to 2000 chars)' : line;",
|
|
"}",
|
|
"function writeJson(result) { process.stdout.write(JSON.stringify(result)); }",
|
|
"function ensureParent(filePath) { fs.mkdirSync(path.dirname(filePath), { recursive: true }); }",
|
|
"function toLines(text) {",
|
|
" if (!text) return [];",
|
|
" const lines = text.split(/\\r?\\n/);",
|
|
" if (text.endsWith('\\n')) lines.pop();",
|
|
" return lines;",
|
|
"}",
|
|
"function readTool() {",
|
|
" const filePath = normalizeRemotePath(args.filePath, workspacePath);",
|
|
" const stat = fs.statSync(filePath);",
|
|
" const offset = Math.max(1, Number(args.offset || 1));",
|
|
" const limit = Math.max(0, Number(args.limit || MAX_LINES));",
|
|
" if (stat.isDirectory()) {",
|
|
" const entries = fs.readdirSync(filePath, { withFileTypes: true }).map((entry) => entry.name + (entry.isDirectory() ? '/' : '')).sort((a, b) => a.localeCompare(b));",
|
|
" const sliced = entries.slice(offset - 1, offset - 1 + limit);",
|
|
" const truncated = offset - 1 + sliced.length < entries.length;",
|
|
" return { output: ['<path>' + filePath + '</path>', '<type>directory</type>', '<entries>', sliced.join('\\n'), truncated ? '\\n(Showing ' + sliced.length + ' of ' + entries.length + ' entries. Use offset=' + (offset + sliced.length) + ' to continue.)' : '\\n(' + entries.length + ' entries)', '</entries>'].join('\\n'), metadata: { preview: sliced.slice(0, 20).join('\\n'), truncated } };",
|
|
" }",
|
|
" const buffer = fs.readFileSync(filePath);",
|
|
" if (buffer.includes(0)) throw new Error('Cannot read binary file: ' + filePath);",
|
|
" const lines = toLines(buffer.toString('utf8'));",
|
|
" if (offset > lines.length && !(lines.length === 0 && offset === 1)) throw new Error('Offset ' + offset + ' is out of range for this file (' + lines.length + ' lines)');",
|
|
" const raw = [];",
|
|
" let bytes = 0;",
|
|
" let cut = false;",
|
|
" for (const line of lines.slice(offset - 1)) {",
|
|
" if (raw.length >= limit) break;",
|
|
" const next = limitLine(line);",
|
|
" const size = Buffer.byteLength(next, 'utf8') + (raw.length > 0 ? 1 : 0);",
|
|
" if (bytes + size > MAX_BYTES) { cut = true; break; }",
|
|
" raw.push(next);",
|
|
" bytes += size;",
|
|
" }",
|
|
" const last = offset + raw.length - 1;",
|
|
" const more = cut || last < lines.length;",
|
|
" let output = '<path>' + filePath + '</path>\\n<type>file</type>\\n<content>\\n';",
|
|
" output += raw.map((line, index) => (index + offset) + ': ' + line).join('\\n');",
|
|
" output += more ? '\\n\\n(Showing lines ' + offset + '-' + last + ' of ' + lines.length + '. Use offset=' + (last + 1) + ' to continue.)' : '\\n\\n(End of file - total ' + lines.length + ' lines)';",
|
|
" output += '\\n</content>';",
|
|
" return { output, metadata: { preview: raw.slice(0, 20).join('\\n'), truncated: more } };",
|
|
"}",
|
|
"function writeTool() {",
|
|
" const filePath = normalizeRemotePath(args.filePath, workspacePath);",
|
|
" const existed = fs.existsSync(filePath);",
|
|
" ensureParent(filePath);",
|
|
" fs.writeFileSync(filePath, String(args.content || ''));",
|
|
" return { output: 'Wrote file successfully.', metadata: { filepath: filePath, exists: existed } };",
|
|
"}",
|
|
"function editTool() {",
|
|
" const filePath = normalizeRemotePath(args.filePath, workspacePath);",
|
|
" if (args.oldString === args.newString) throw new Error('No changes to apply: oldString and newString are identical.');",
|
|
" let content = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : '';",
|
|
" let next;",
|
|
" if (args.oldString === '') {",
|
|
" next = String(args.newString || '');",
|
|
" } else {",
|
|
" const oldString = String(args.oldString || '');",
|
|
" const newString = String(args.newString || '');",
|
|
" const matches = content.split(oldString).length - 1;",
|
|
" if (matches === 0) throw new Error('Could not find oldString in the file. It must match exactly.');",
|
|
" if (!args.replaceAll && matches > 1) throw new Error('Found multiple matches for oldString. Provide more surrounding context or set replaceAll.');",
|
|
" next = args.replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);",
|
|
" }",
|
|
" ensureParent(filePath);",
|
|
" fs.writeFileSync(filePath, next);",
|
|
" return { output: 'Edit applied successfully.', metadata: { filepath: filePath } };",
|
|
"}",
|
|
"function bashTool() {",
|
|
" const cwd = normalizeRemotePath(args.workdir, workspacePath);",
|
|
" const timeout = Number(args.timeout || 120000);",
|
|
" const shell = process.env.SHELL || '/bin/sh';",
|
|
" const result = childProcess.spawnSync(shell, ['-lc', String(args.command || '')], { cwd, encoding: 'utf8', timeout, maxBuffer: 10 * 1024 * 1024 });",
|
|
" const outputText = [result.stdout || '', result.stderr || ''].filter(Boolean).join('');",
|
|
" const metadata = [];",
|
|
" if (result.error && result.error.code === 'ETIMEDOUT') metadata.push('remote shell tool terminated command after exceeding timeout ' + timeout + ' ms.');",
|
|
" metadata.push('exit=' + (result.status === null || result.status === undefined ? 1 : result.status));",
|
|
" const output = (outputText.trim() ? outputText.replace(/\\s+$/g, '') : '(no output)') + '\\n\\n<shell_metadata>\\n' + metadata.join('\\n') + '\\n</shell_metadata>';",
|
|
" return { output, metadata: { exit: result.status, cwd } };",
|
|
"}",
|
|
"function grepTool() {",
|
|
" if (!args.pattern) throw new Error('pattern is required');",
|
|
" const search = normalizeRemotePath(args.path, workspacePath);",
|
|
" const executable = fs.existsSync(rgPath) ? rgPath : 'rg';",
|
|
" const rgArgs = ['--line-number', '--with-filename', '--color', 'never', '--no-heading'];",
|
|
" if (args.include) rgArgs.push('--glob', String(args.include));",
|
|
" rgArgs.push('--', String(args.pattern), search);",
|
|
" const result = childProcess.spawnSync(executable, rgArgs, { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });",
|
|
" if (result.status !== 0 && result.status !== 1) throw new Error(result.stderr || ('ripgrep failed with exit ' + result.status));",
|
|
" const rows = (result.stdout || '').split(/\\r?\\n/).filter(Boolean).map((line) => { const match = line.match(/^(.*?):(\\d+):(.*)$/); if (!match) return undefined; const filePath = path.resolve(match[1]); let mtime = 0; try { mtime = fs.statSync(filePath).mtimeMs; } catch {} return { path: filePath, line: Number(match[2]), text: match[3], mtime }; }).filter(Boolean);",
|
|
" rows.sort((left, right) => right.mtime - left.mtime);",
|
|
" const limit = 100;",
|
|
" const truncated = rows.length > limit;",
|
|
" const finalRows = truncated ? rows.slice(0, limit) : rows;",
|
|
" if (finalRows.length === 0) return { output: 'No files found', metadata: { matches: 0, truncated: false } };",
|
|
" const output = ['Found ' + rows.length + ' matches' + (truncated ? ' (showing first ' + limit + ')' : '')];",
|
|
" let current = '';",
|
|
" for (const row of finalRows) { if (current !== row.path) { if (current) output.push(''); current = row.path; output.push(row.path + ':'); } output.push(' Line ' + row.line + ': ' + limitLine(row.text)); }",
|
|
" if (truncated) output.push('', '(Results truncated: showing ' + limit + ' of ' + rows.length + ' matches.)');",
|
|
" return { output: output.join('\\n'), metadata: { matches: rows.length, truncated } };",
|
|
"}",
|
|
"function globTool() {",
|
|
" if (!args.pattern) throw new Error('pattern is required');",
|
|
" const search = normalizeRemotePath(args.path, workspacePath);",
|
|
" const executable = fs.existsSync(rgPath) ? rgPath : 'rg';",
|
|
" const result = childProcess.spawnSync(executable, ['--files', '--color', 'never', '--glob', String(args.pattern), '--', search], { encoding: 'utf8', maxBuffer: 10 * 1024 * 1024 });",
|
|
" if (result.status !== 0 && result.status !== 1) throw new Error(result.stderr || ('ripgrep failed with exit ' + result.status));",
|
|
" const files = (result.stdout || '').split(/\\r?\\n/).filter(Boolean).map((entry) => path.isAbsolute(entry) ? entry : path.resolve(search, entry)).map((filePath) => { let mtime = 0; try { mtime = fs.statSync(filePath).mtimeMs; } catch {} return { path: filePath, mtime }; }).sort((left, right) => right.mtime - left.mtime);",
|
|
" const limit = 100;",
|
|
" const truncated = files.length > limit;",
|
|
" const finalFiles = truncated ? files.slice(0, limit) : files;",
|
|
" const output = finalFiles.length ? finalFiles.map((file) => file.path) : ['No files found'];",
|
|
" if (truncated) output.push('', '(Results are truncated: showing first ' + limit + ' results.)');",
|
|
" return { output: output.join('\\n'), metadata: { count: finalFiles.length, truncated } };",
|
|
"}",
|
|
"function parsePatch(text) {",
|
|
" const lines = String(text || '').replace(/\\r\\n/g, '\\n').replace(/\\r/g, '\\n').split('\\n');",
|
|
" if (lines[0] !== '*** Begin Patch') throw new Error('apply_patch verification failed: missing begin marker');",
|
|
" const ops = [];",
|
|
" let index = 1;",
|
|
" while (index < lines.length) {",
|
|
" const line = lines[index];",
|
|
" if (line === '*** End Patch') break;",
|
|
" if (line.startsWith('*** Add File: ')) { const file = line.slice(14); const body = []; index++; while (index < lines.length && !lines[index].startsWith('*** ')) { if (!lines[index].startsWith('+')) throw new Error('add file lines must start with +'); body.push(lines[index].slice(1)); index++; } ops.push({ type: 'add', file, body }); continue; }",
|
|
" if (line.startsWith('*** Delete File: ')) { ops.push({ type: 'delete', file: line.slice(17) }); index++; continue; }",
|
|
" if (line.startsWith('*** Update File: ')) { const file = line.slice(17); const body = []; let moveTo; index++; if (lines[index] && lines[index].startsWith('*** Move to: ')) { moveTo = lines[index].slice(13); index++; } while (index < lines.length && !lines[index].startsWith('*** ')) { body.push(lines[index]); index++; } ops.push({ type: 'update', file, moveTo, body }); continue; }",
|
|
" throw new Error('apply_patch verification failed: unknown patch line ' + line);",
|
|
" }",
|
|
" if (ops.length === 0) throw new Error('patch rejected: empty patch');",
|
|
" return ops;",
|
|
"}",
|
|
"function replaceHunk(content, oldLines, newLines) {",
|
|
" const oldText = oldLines.join('\\n');",
|
|
" const newText = newLines.join('\\n');",
|
|
" const candidates = oldLines.length === 0 ? [['', newText]] : [[oldText + '\\n', newText + '\\n'], [oldText, newText]];",
|
|
" for (const pair of candidates) { const from = pair[0]; const to = pair[1]; const position = from === '' ? content.length : content.indexOf(from); if (position !== -1) return content.slice(0, position) + to + content.slice(position + from.length); }",
|
|
" throw new Error('apply_patch verification failed: hunk context not found');",
|
|
"}",
|
|
"function applyPatchTool() {",
|
|
" const ops = parsePatch(args.patchText);",
|
|
" const summary = [];",
|
|
" for (const op of ops) {",
|
|
" const filePath = normalizeRemotePath(op.file, workspacePath);",
|
|
" if (op.type === 'add') { ensureParent(filePath); fs.writeFileSync(filePath, op.body.join('\\n') + (op.body.length ? '\\n' : '')); summary.push('A ' + path.relative(workspacePath, filePath)); continue; }",
|
|
" if (op.type === 'delete') { fs.rmSync(filePath, { force: true }); summary.push('D ' + path.relative(workspacePath, filePath)); continue; }",
|
|
" let content = fs.readFileSync(filePath, 'utf8');",
|
|
" const groups = []; let current = [];",
|
|
" for (const line of op.body) { if (line.startsWith('@@')) { if (current.length) groups.push(current); current = []; continue; } current.push(line); }",
|
|
" if (current.length) groups.push(current);",
|
|
" for (const group of groups) { const oldLines = []; const newLines = []; for (const line of group) { if (!line) continue; const marker = line[0]; const value = line.slice(1); if (marker === ' ') { oldLines.push(value); newLines.push(value); } else if (marker === '-') { oldLines.push(value); } else if (marker === '+') { newLines.push(value); } else if (line.startsWith('\\\\ No newline')) { } else { throw new Error('apply_patch verification failed: invalid hunk line ' + line); } } content = replaceHunk(content, oldLines, newLines); }",
|
|
" const targetPath = op.moveTo ? normalizeRemotePath(op.moveTo, workspacePath) : filePath;",
|
|
" ensureParent(targetPath); fs.writeFileSync(targetPath, content); if (op.moveTo) fs.rmSync(filePath, { force: true }); summary.push('M ' + path.relative(workspacePath, targetPath));",
|
|
" }",
|
|
" return { output: 'Success. Updated the following files:\\n' + summary.join('\\n'), metadata: { files: summary } };",
|
|
"}",
|
|
"try {",
|
|
" const handlers = { bash: bashTool, read: readTool, write: writeTool, edit: editTool, grep: grepTool, glob: globTool, apply_patch: applyPatchTool };",
|
|
" if (!handlers[toolName]) throw new Error('Unsupported Git.Zone OpenCode tool: ' + toolName);",
|
|
" writeJson(handlers[toolName]());",
|
|
"} catch (error) {",
|
|
" console.error(error && error.stack ? error.stack : String(error));",
|
|
" process.exit(1);",
|
|
"}",
|
|
].join('\n');
|
|
|
|
export const quoteShellArg = (value: string | number | boolean) => {
|
|
const stringValue = String(value);
|
|
if (stringValue.length === 0) {
|
|
return "''";
|
|
}
|
|
return `'${stringValue.replace(/'/g, `'"'"'`)}'`;
|
|
};
|
|
|
|
export const quoteRemotePath = (value: string | number | boolean) => {
|
|
const stringValue = String(value);
|
|
if (stringValue === '~' || stringValue === '$HOME' || stringValue === '${HOME}') {
|
|
return '"$HOME"';
|
|
}
|
|
|
|
for (const prefix of ['~/', '$HOME/', '${HOME}/']) {
|
|
if (stringValue.startsWith(prefix)) {
|
|
const suffix = stringValue.slice(prefix.length);
|
|
return suffix ? `"$HOME"/${quoteShellArg(suffix)}` : '"$HOME"';
|
|
}
|
|
}
|
|
|
|
return quoteShellArg(stringValue);
|
|
};
|
|
|
|
export const joinRemotePath = (...parts: string[]) => {
|
|
const [first, ...rest] = parts.filter(Boolean);
|
|
if (!first) {
|
|
return '';
|
|
}
|
|
return [trimTrailingSlash(first), ...rest.map((part) => part.replace(/^\/+|\/+$/g, ''))]
|
|
.filter(Boolean)
|
|
.join('/');
|
|
};
|
|
|
|
const trimTrailingSlash = (value: string) => value.replace(/\/+$/g, '');
|