tide-commander 1.154.0 → 1.156.0

package/dist/src/packages/server/opencode/server/opencode-server-runner.js

@@ -0,0 +1,384 @@
+/**
+ * OpencodeServerRunner — experimental runtime that drives OpenCode agents through
+ * a persistent, restart-surviving `opencode serve` HTTP server instead of one
+ * `opencode run` process per turn.
+ *
+ * Why: `opencode run --format json` emits one full assistant message (no token
+ * deltas), so replies never typewriter. The server streams `message.part.delta`
+ * tokens over SSE. And a detached server survives commander restarts, keeping any
+ * in-flight turn running; on boot the runner reconnects the SSE stream and
+ * OpenCode's persisted sessions resume seamlessly.
+ *
+ * Downstream reuse: reconstructed StandardEvents feed a shared
+ * RunnerStdoutPipeline via `emitStandardEvent` (the OpencodeBackend's
+ * `.name === 'opencode'` turns on stream-coalescing), so websocket broadcast,
+ * client merge-by-uuid, boss delegation and context tracking are reused unchanged.
+ */
+import * as os from 'os';
+import { OpencodeBackend, buildOpencodePrompt } from '../backend.js';
+import { RunnerInternalEventBus } from '../../claude/runner/internal-events.js';
+import { RunnerStdoutPipeline } from '../../claude/runner/stdout-pipeline.js';
+import { OpencodeServerProcess } from './opencode-server-process.js';
+import { OpencodeServerEventAdapter } from './opencode-server-event-adapter.js';
+import { loadOpencodeAgents, saveOpencodeAgents, } from './opencode-server-recovery-store.js';
+import * as agentService from '../../services/agent-service.js';
+import { createLogger } from '../../utils/logger.js';
+import { withAgentContext } from '../../utils/log-context.js';
+const log = createLogger('OpencodeServerRunner');
+const RECOVER_DELAY_MS = 1500;
+export class OpencodeServerRunner {
+    callbacks;
+    backend = new OpencodeBackend();
+    bus = new RunnerInternalEventBus();
+    pipeline;
+    agents = new Map();
+    sessionToAgent = new Map();
+    activityCallbacks = new Map();
+    process = null;
+    started = false;
+    recovered = false;
+    constructor(callbacks) {
+        this.callbacks = callbacks;
+        this.pipeline = new RunnerStdoutPipeline({
+            backend: this.backend,
+            callbacks: this.callbacks,
+            bus: this.bus,
+        });
+    }
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        setTimeout(() => { void this.recover(); }, RECOVER_DELAY_MS);
+        log.log('🛡️ OpenCode server runner started (streaming, restart-surviving)');
+    }
+    ensureProcess(spawnCwd) {
+        if (this.process && this.process.isAlive())
+            return this.process;
+        this.process = new OpencodeServerProcess({
+            executablePath: this.backend.getExecutablePath(),
+            cwd: spawnCwd || os.homedir(),
+            extraEnv: this.backend.getExtraEnv(),
+            onEvent: (evt) => this.routeEvent(evt),
+            onDisconnect: () => this.handleDisconnect(),
+        });
+        return this.process;
+    }
+    async recover() {
+        const persisted = loadOpencodeAgents();
+        this.recovered = true;
+        if (persisted.length === 0) {
+            this.persistAgents();
+            return;
+        }
+        const spawnCwd = persisted[0].workingDir || os.homedir();
+        const proc = this.ensureProcess(spawnCwd);
+        try {
+            await proc.ensureStarted();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.warn(`Recovery: could not reach opencode server (${msg}); agents will lazy-resume on next message`);
+            this.finalizeStale(persisted);
+            return;
+        }
+        if (!proc.didReconnect()) {
+            log.log('Recovery: fresh server (old turns gone); finalizing mid-turn agents');
+            this.finalizeStale(persisted);
+            return;
+        }
+        log.log(`🔗 Recovery: rejoined server; re-attaching ${persisted.length} session(s)`);
+        const active = await proc.activeSessionIds();
+        for (const p of persisted) {
+            const state = {
+                sessionId: p.sessionId,
+                adapter: new OpencodeServerEventAdapter(),
+                turnState: p.turnState,
+                startTime: Date.now(),
+                lastActivityTime: Date.now(),
+                lastRequest: p.lastRequest,
+                queue: [],
+            };
+            this.agents.set(p.agentId, state);
+            this.sessionToAgent.set(p.sessionId, p.agentId);
+            if (active.has(p.sessionId)) {
+                // Turn still generating — the SSE stream will deliver its remaining
+                // deltas + session.idle, which finalizes it via applyEvent().
+                if (agentService.getAgent(p.agentId))
+                    agentService.updateAgent(p.agentId, { status: 'working' });
+                state.turnState = 'processing';
+            }
+            else {
+                // Turn ended during downtime — finalize now (no session.idle will replay).
+                state.turnState = 'waiting_for_input';
+                this.callbacks.onComplete(p.agentId, true);
+            }
+        }
+        this.persistAgents();
+    }
+    finalizeStale(persisted) {
+        for (const p of persisted) {
+            if (p.agentStatus === 'working' || p.turnState === 'processing') {
+                this.callbacks.onComplete(p.agentId, true);
+            }
+        }
+        saveOpencodeAgents([]);
+    }
+    handleDisconnect() {
+        const agentIds = [...this.agents.keys()];
+        log.warn(`opencode server connection lost — finalizing ${agentIds.length} agent(s)`);
+        this.agents.clear();
+        this.sessionToAgent.clear();
+        this.process = null;
+        for (const agentId of agentIds)
+            this.callbacks.onComplete(agentId, false);
+    }
+    routeEvent(evt) {
+        const props = evt.properties || {};
+        const sessionId = props.sessionID || evt.sessionID;
+        if (!sessionId)
+            return;
+        const agentId = this.sessionToAgent.get(sessionId);
+        if (!agentId)
+            return;
+        const state = this.agents.get(agentId);
+        if (!state)
+            return;
+        state.lastActivityTime = Date.now();
+        this.fireActivity(agentId);
+        for (const event of state.adapter.handle(evt)) {
+            this.applyEvent(agentId, state, event);
+        }
+    }
+    applyEvent(agentId, state, event) {
+        if (event.type === 'text' || event.type === 'tool_start' || event.type === 'thinking' || event.type === 'init') {
+            state.turnState = 'processing';
+        }
+        this.pipeline.emitStandardEvent(agentId, event);
+        if (event.type === 'step_complete') {
+            state.turnState = 'waiting_for_input';
+            this.persistAgents();
+            // The server stays alive across turns, so there's no process 'close' to
+            // flip the agent idle. runtime-events skips the idle transition for
+            // opencode on step_complete (it expects it on process exit), so drive it here.
+            this.callbacks.onComplete(agentId, true);
+            this.drainQueue(agentId, state);
+        }
+    }
+    async run(request) {
+        await withAgentContext(request.agentId, () => this.runImpl(request));
+    }
+    async runImpl(request) {
+        const { agentId, workingDir } = request;
+        const proc = this.ensureProcess(workingDir);
+        try {
+            await proc.ensureStarted();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(`Failed to start opencode server for ${agentId.slice(0, 8)}: ${msg}`);
+            this.callbacks.onError(agentId, `OpenCode server failed to start: ${msg}`);
+            return;
+        }
+        const wantNew = request.forceNewSession || !request.sessionId;
+        let state = this.agents.get(agentId);
+        if (state && wantNew) {
+            this.sessionToAgent.delete(state.sessionId);
+            this.agents.delete(agentId);
+            state = undefined;
+        }
+        let injectInstructions = false;
+        if (!state) {
+            let sessionId;
+            if (!wantNew && request.sessionId) {
+                sessionId = request.sessionId; // resume an existing persisted session
+            }
+            else {
+                try {
+                    sessionId = await proc.createSession(workingDir);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    log.error(`createSession failed for ${agentId.slice(0, 8)}: ${msg}`);
+                    this.callbacks.onError(agentId, `OpenCode session create failed: ${msg}`);
+                    return;
+                }
+                injectInstructions = true;
+            }
+            state = {
+                sessionId,
+                adapter: new OpencodeServerEventAdapter(),
+                turnState: 'processing',
+                startTime: Date.now(),
+                lastActivityTime: Date.now(),
+                lastRequest: request,
+                queue: [],
+            };
+            this.agents.set(agentId, state);
+            this.sessionToAgent.set(sessionId, agentId);
+            agentService.updateAgent(agentId, { sessionId });
+            this.callbacks.onSessionId(agentId, sessionId);
+            this.pipeline.emitStandardEvent(agentId, { type: 'init', sessionId, model: request.model || 'opencode' });
+        }
+        else {
+            state.lastRequest = request;
+        }
+        await this.startTurn(agentId, state, request.prompt, proc, injectInstructions);
+        this.persistAgents();
+    }
+    modelRef(model) {
+        if (!model)
+            return undefined;
+        const slash = model.indexOf('/');
+        if (slash <= 0)
+            return undefined; // no provider prefix → let the server default
+        return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
+    }
+    async startTurn(agentId, state, prompt, proc, injectInstructions) {
+        // Reuse the exec prompt builder. Passing sessionId makes it send only the
+        // user prompt on follow-ups (the instruction block is already in the session
+        // history); on the very first turn of a new session we omit sessionId so the
+        // full block is injected once — same behaviour as the exec resume path.
+        const config = {
+            agentId,
+            sessionId: injectInstructions ? undefined : state.sessionId,
+            model: state.lastRequest.model,
+            workingDir: state.lastRequest.workingDir,
+            systemPrompt: state.lastRequest.systemPrompt,
+            customAgent: state.lastRequest.customAgent,
+            prompt,
+        };
+        const promptText = buildOpencodePrompt(config);
+        state.turnState = 'processing';
+        state.lastActivityTime = Date.now();
+        try {
+            await proc.sendPrompt(state.sessionId, promptText, this.modelRef(state.lastRequest.model));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log.error(`sendPrompt failed for ${agentId.slice(0, 8)}: ${msg}`);
+            this.callbacks.onError(agentId, `OpenCode prompt failed: ${msg}`);
+        }
+    }
+    drainQueue(agentId, state) {
+        if (state.queue.length === 0)
+            return;
+        const next = state.queue.shift();
+        const proc = this.process;
+        if (!proc || !proc.isAlive()) {
+            state.queue.unshift(next);
+            return;
+        }
+        log.log(`📤 Delivering queued follow-up to ${agentId.slice(0, 8)} (${state.queue.length} remaining)`);
+        agentService.updateAgent(agentId, { status: 'working', currentTask: next.substring(0, 100) });
+        void this.startTurn(agentId, state, next, proc, false);
+    }
+    sendMessage(agentId, message) {
+        return withAgentContext(agentId, () => {
+            const state = this.agents.get(agentId);
+            if (!state) {
+                log.warn(`sendMessage: no live session for ${agentId.slice(0, 8)}`);
+                return false;
+            }
+            const proc = this.process;
+            if (!proc || !proc.isAlive())
+                return false;
+            if (state.turnState === 'processing') {
+                state.queue.push(message);
+                log.log(`📋 Queued mid-turn message for ${agentId.slice(0, 8)} (queue=${state.queue.length})`);
+                return true;
+            }
+            void this.startTurn(agentId, state, message, proc, false);
+            return true;
+        });
+    }
+    async stop(agentId, _clearQueue = true) {
+        await withAgentContext(agentId, async () => {
+            const state = this.agents.get(agentId);
+            if (!state)
+                return;
+            const proc = this.process;
+            if (proc && proc.isAlive() && state.turnState === 'processing') {
+                await proc.abort(state.sessionId);
+            }
+            this.sessionToAgent.delete(state.sessionId);
+            this.agents.delete(agentId);
+            this.activityCallbacks.delete(agentId);
+            this.persistAgents();
+        });
+    }
+    async stopAll(killProcesses = true, _clearQueue) {
+        this.agents.clear();
+        this.sessionToAgent.clear();
+        this.activityCallbacks.clear();
+        if (this.process) {
+            if (killProcesses) {
+                this.process.killDaemon();
+                saveOpencodeAgents([]);
+            }
+            else {
+                this.persistAgents();
+                this.process.disconnect();
+            }
+            this.process = null;
+        }
+    }
+    isRunning(agentId) {
+        return this.agents.has(agentId) && this.process !== null && this.process.isAlive();
+    }
+    supportsStdin() {
+        return true;
+    }
+    closesStdinAfterPrompt() {
+        return false;
+    }
+    getTurnState(agentId) {
+        return this.agents.get(agentId)?.turnState;
+    }
+    hasRecentActivity(agentId, withinMs) {
+        const state = this.agents.get(agentId);
+        if (!state)
+            return false;
+        const last = state.lastActivityTime || state.startTime;
+        return Date.now() - last < withinMs;
+    }
+    onNextActivity(agentId, callback) {
+        if (!this.activityCallbacks.has(agentId))
+            this.activityCallbacks.set(agentId, []);
+        this.activityCallbacks.get(agentId).push(callback);
+    }
+    fireActivity(agentId) {
+        const cbs = this.activityCallbacks.get(agentId);
+        if (!cbs || cbs.length === 0)
+            return;
+        this.activityCallbacks.delete(agentId);
+        for (const cb of cbs) {
+            try {
+                cb();
+            }
+            catch (err) {
+                log.error(`Activity callback error for ${agentId}:`, err);
+            }
+        }
+    }
+    persistAgents() {
+        if (!this.recovered)
+            return;
+        const list = [];
+        for (const [agentId, state] of this.agents) {
+            const agent = agentService.getAgent(agentId);
+            list.push({
+                agentId,
+                sessionId: state.sessionId,
+                workingDir: state.lastRequest.workingDir,
+                turnState: state.turnState,
+                agentStatus: agent?.status,
+                lastRequest: state.lastRequest,
+            });
+        }
+        saveOpencodeAgents(list);
+    }
+    getActiveProcessesState() {
+        return [...this.agents.keys()].map((agentId) => ({ agentId, pid: undefined }));
+    }
+}

package/dist/src/packages/server/routes/agents.js

@@ -18,7 +18,7 @@ import { truncateOrEmpty } from '../utils/string.js';
 import { buildCustomAgentConfig, expandFileMentions } from '../websocket/handlers/command-handler.js';
 import { clearDelegation, getBossForSubordinate } from '../websocket/handlers/boss-response-handler.js';
 import { OpencodeBackend } from '../opencode/backend.js';
-import { getSystemPrompt, setSystemPrompt, clearSystemPrompt, isEchoPromptEnabled, setEchoPromptEnabled, getCodexBinaryPath, setCodexBinaryPath, isTmuxModeEnabled, setTmuxModeEnabled, isInteractiveModeEnabled, setInteractiveModeEnabled, isCodexAppServerModeEnabled, setCodexAppServerModeEnabled } from '../services/system-prompt-service.js';
+import { getSystemPrompt, setSystemPrompt, clearSystemPrompt, isEchoPromptEnabled, setEchoPromptEnabled, getCodexBinaryPath, setCodexBinaryPath, isTmuxModeEnabled, setTmuxModeEnabled, isInteractiveModeEnabled, setInteractiveModeEnabled, isCodexAppServerModeEnabled, setCodexAppServerModeEnabled, isOpencodeServerModeEnabled, setOpencodeServerModeEnabled } from '../services/system-prompt-service.js';
 import { markInstructionsDirtyForAll } from '../services/instruction-refresh.js';
 import { startAgentTerminal, stopAgentTerminal } from '../services/agent-terminal-service.js';
 import { buildClaudeUsageByAgentSummary, buildClaudeUsageByDaySummary, buildClaudeUsageSnapshot } from '../services/claude-usage-service.js';
@@ -1529,6 +1529,34 @@ router.post('/system-settings/codex-app-server-mode', (req, res) => {
         res.status(500).json({ error: err.message });
     }
 });
+// GET /api/system-settings/opencode-server-mode - Get experimental OpenCode server (streaming) mode setting
+router.get('/system-settings/opencode-server-mode', (_req, res) => {
+    try {
+        const enabled = isOpencodeServerModeEnabled();
+        res.json({ enabled });
+    }
+    catch (err) {
+        log.error(' Failed to get opencode server mode setting:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
+// POST /api/system-settings/opencode-server-mode - Update experimental OpenCode server (streaming) mode setting
+router.post('/system-settings/opencode-server-mode', (req, res) => {
+    try {
+        const { enabled } = req.body;
+        if (typeof enabled !== 'boolean') {
+            res.status(400).json({ error: 'enabled must be a boolean' });
+            return;
+        }
+        setOpencodeServerModeEnabled(enabled);
+        log.log(` OpenCode server mode setting updated: enabled=${enabled}`);
+        res.json({ success: true, enabled });
+    }
+    catch (err) {
+        log.error(' Failed to set opencode server mode setting:', err);
+        res.status(500).json({ error: err.message });
+    }
+});
 // GET /api/system-settings/backup - Get hourly backup scheduler status
 router.get('/system-settings/backup', (_req, res) => {
     try {

package/dist/src/packages/server/runtime/opencode-runner-router.js

@@ -0,0 +1,93 @@
+/**
+ * OpencodeRunnerRouter
+ *
+ * OpenCode agents can run two ways: the default per-turn `opencode run` runner
+ * (ClaudeRunner driving an OpencodeBackend), or the experimental persistent
+ * `opencode serve` runner that streams word-by-word `message.part.delta` tokens
+ * over SSE and survives commander restarts. A NEW launch's mode is decided
+ * per-run from the LIVE setting (isOpencodeServerModeEnabled) — no restart to
+ * switch — mirroring ClaudeRunnerRouter and CodexRunnerRouter.
+ */
+import { ClaudeRunner } from '../claude/runner.js';
+import { OpencodeBackend } from '../opencode/backend.js';
+import { OpencodeServerRunner } from '../opencode/server/opencode-server-runner.js';
+import { isOpencodeServerModeEnabled } from '../services/system-prompt-service.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('OpencodeRouter');
+export class OpencodeRunnerRouter {
+    run_;
+    server;
+    owner = new Map();
+    constructor(callbacks) {
+        this.run_ = new ClaudeRunner(callbacks, new OpencodeBackend());
+        this.server = new OpencodeServerRunner(callbacks);
+    }
+    currentMode() {
+        return isOpencodeServerModeEnabled() ? 'server' : 'run';
+    }
+    runnerFor(mode) {
+        return mode === 'server' ? this.server : this.run_;
+    }
+    ownerOf(agentId) {
+        if (this.server.isRunning(agentId))
+            return 'server';
+        if (this.run_.isRunning(agentId))
+            return 'run';
+        return this.owner.get(agentId);
+    }
+    ownerRunner(agentId) {
+        return this.runnerFor(this.ownerOf(agentId) ?? this.currentMode());
+    }
+    start() {
+        this.run_.start?.();
+        this.server.start?.();
+    }
+    async run(request) {
+        const mode = this.currentMode();
+        const prev = this.ownerOf(request.agentId);
+        if (prev && prev !== mode) {
+            log.log(`Agent ${request.agentId.slice(0, 8)} switching ${prev} → ${mode}; stopping old runner first`);
+            await this.runnerFor(prev).stop(request.agentId, false);
+        }
+        this.owner.set(request.agentId, mode);
+        return this.runnerFor(mode).run(request);
+    }
+    sendMessage(agentId, message) {
+        return this.ownerRunner(agentId).sendMessage(agentId, message);
+    }
+    async stop(agentId, clearQueue) {
+        await this.run_.stop(agentId, clearQueue);
+        await this.server.stop(agentId, clearQueue);
+        this.owner.delete(agentId);
+    }
+    async stopAll(killProcesses, clearQueue) {
+        await this.run_.stopAll(killProcesses, clearQueue);
+        await this.server.stopAll(killProcesses, clearQueue);
+        this.owner.clear();
+    }
+    isRunning(agentId) {
+        return this.run_.isRunning(agentId) || this.server.isRunning(agentId);
+    }
+    hasRecentActivity(agentId, withinMs) {
+        return this.ownerRunner(agentId).hasRecentActivity(agentId, withinMs);
+    }
+    onNextActivity(agentId, callback) {
+        this.ownerRunner(agentId).onNextActivity(agentId, callback);
+    }
+    supportsStdin() {
+        return true;
+    }
+    closesStdinAfterPrompt() {
+        // Mode-dependent: `opencode run` closes stdin per turn, the server keeps the
+        // session open. Report per the current setting so the delivery path matches.
+        return this.currentMode() === 'run';
+    }
+    getTurnState(agentId) {
+        return this.ownerRunner(agentId).getTurnState?.(agentId);
+    }
+    getActiveProcessesState() {
+        const runState = this.run_.getActiveProcessesState().map((p) => ({ agentId: p.agentId, pid: p.pid }));
+        const serverState = this.server.getActiveProcessesState();
+        return [...runState, ...serverState];
+    }
+}

package/dist/src/packages/server/runtime/opencode-runtime-provider.js

@@ -1,9 +1,11 @@
-import { ClaudeRunner } from '../claude/runner.js';
-import { OpencodeBackend } from '../opencode/backend.js';
+import { OpencodeRunnerRouter } from './opencode-runner-router.js';
 class OpencodeRuntimeProvider {
     name = 'opencode';
     createRunner(callbacks) {
-        return new ClaudeRunner(callbacks, new OpencodeBackend());
+        // The router picks per-launch between the default `opencode run` runner and
+        // the experimental persistent `opencode serve` runner (streaming), driven by
+        // the live isOpencodeServerModeEnabled() setting.
+        return new OpencodeRunnerRouter(callbacks);
     }
 }
 export function createOpencodeRuntimeProvider() {

package/dist/src/packages/server/services/system-prompt-service.js

@@ -319,7 +319,9 @@ export function isCodexAppServerModeEnabled() {
     catch (error) {
         log.error(` Failed to load codex app-server mode setting: ${error.message}`);
     }
-    return false;
+    // Default ON: streaming (app-server) is the default for Codex agents. An
+    // explicit toggle-off is still respected (the file above wins).
+    return true;
 }
 /**
  * Enable/disable experimental Codex app-server (streaming) mode.
@@ -339,3 +341,49 @@ export function setCodexAppServerModeEnabled(enabled) {
         throw error;
     }
 }
+// ============================================================================
+// OpenCode Server Mode Setting
+// ============================================================================
+//
+// Experimental: when enabled, OpenCode agents run through a persistent, detached
+// `opencode serve` HTTP server instead of one `opencode run` process per turn.
+// The server streams word-by-word `message.part.delta` tokens over SSE (which
+// `opencode run --format json` never emits) and survives commander restarts.
+// Read live at each launch — no server restart needed to switch.
+const OPENCODE_SERVER_MODE_FILE = path.join(DATA_DIR, 'opencode-server-mode.json');
+/**
+ * Check if experimental OpenCode server (streaming) mode is enabled.
+ */
+export function isOpencodeServerModeEnabled() {
+    ensureDataDir();
+    try {
+        if (fs.existsSync(OPENCODE_SERVER_MODE_FILE)) {
+            const data = JSON.parse(fs.readFileSync(OPENCODE_SERVER_MODE_FILE, 'utf-8'));
+            return data.enabled;
+        }
+    }
+    catch (error) {
+        log.error(` Failed to load opencode server mode setting: ${error.message}`);
+    }
+    // Default ON: streaming (opencode serve) is the default for OpenCode agents.
+    // An explicit toggle-off is still respected (the file above wins).
+    return true;
+}
+/**
+ * Enable/disable experimental OpenCode server (streaming) mode.
+ */
+export function setOpencodeServerModeEnabled(enabled) {
+    ensureDataDir();
+    const data = {
+        enabled,
+        updatedAt: Date.now(),
+    };
+    try {
+        fs.writeFileSync(OPENCODE_SERVER_MODE_FILE, JSON.stringify(data, null, 2), 'utf-8');
+        log.log(` OpenCode server mode setting updated: enabled=${enabled}`);
+    }
+    catch (error) {
+        log.error(` Failed to save opencode server mode setting: ${error.message}`);
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tide-commander",
-  "version": "1.154.0",
+  "version": "1.156.0",
   "description": "Visual multi-agent orchestrator and manager for Claude Code with 3D/2D interface",
   "repository": {
     "type": "git",