teamcopilot 0.1.2 → 0.1.4

package/dist/utils/workspace-sync.js

@@ -14,6 +14,7 @@ const path_1 = __importDefault(require("path"));
 const ignore_1 = __importDefault(require("ignore"));
 const child_process_1 = require("child_process");
 const util_1 = require("util");
+const crypto_1 = __importDefault(require("crypto"));
 const assert_1 = require("./assert");
 const runtime_paths_1 = require("./runtime-paths");
 const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
@@ -22,6 +23,7 @@ const WORKSPACE_DB_FILENAME = "data.db";
 const HONEYTOKEN_UUID = "1f9f0b72-5f9f-4c9b-aef1-2fb2e0f6d8c4";
 const HONEYTOKEN_FILE_NAME = `honeytoken-${HONEYTOKEN_UUID}.txt`;
 const WORKSPACE_AZURE_PROVIDER_VERSION = "3.0.48";
+const WORKSPACE_INSTALL_STATE_RELATIVE_PATH = path_1.default.join(".opencode", "install-state.json");
 function getWorkspaceDirFromEnv() {
     let workspaceDir = (0, assert_1.assertEnv)("WORKSPACE_DIR");
     if (!path_1.default.isAbsolute(workspaceDir)) {
@@ -59,6 +61,9 @@ function shouldSkipManagedDirectoryContent(relativePath) {
     if (relativePath === ".opencode/xdg-data" || relativePath.startsWith(".opencode/xdg-data/")) {
         return true;
     }
+    if (relativePath === normalizeRelativePath(WORKSPACE_INSTALL_STATE_RELATIVE_PATH)) {
+        return true;
+    }
     return false;
 }
 function evaluateIgnoreRuleSets(relativePath, isDirectory, ruleSets) {
@@ -204,11 +209,30 @@ async function initializeWorkspaceNodeDependencies(workspaceDir) {
         ...existingPackageJson,
         dependencies,
     };
+    const installStatePath = path_1.default.join(workspaceDir, WORKSPACE_INSTALL_STATE_RELATIVE_PATH);
+    const desiredInstallState = {
+        dependencies,
+    };
+    const desiredInstallStateHash = crypto_1.default
+        .createHash("sha256")
+        .update(JSON.stringify(desiredInstallState))
+        .digest("hex");
+    const existingInstallState = fs_1.default.existsSync(installStatePath)
+        ? JSON.parse(fs_1.default.readFileSync(installStatePath, "utf-8"))
+        : null;
+    const hasMatchingInstallState = existingInstallState?.hash === desiredInstallStateHash;
+    const nodeModulesPath = path_1.default.join(workspaceDir, "node_modules");
+    const packageJsonMatches = JSON.stringify(existingPackageJson) === JSON.stringify(workspacePackageJson);
+    if (hasMatchingInstallState && packageJsonMatches && fs_1.default.existsSync(nodeModulesPath)) {
+        return;
+    }
     fs_1.default.writeFileSync(workspacePackageJsonPath, JSON.stringify(workspacePackageJson, null, 2), "utf-8");
     await execFileAsync("npm", ["install"], {
         cwd: workspaceDir,
         env: process.env,
     });
+    fs_1.default.mkdirSync(path_1.default.dirname(installStatePath), { recursive: true });
+    fs_1.default.writeFileSync(installStatePath, `${JSON.stringify({ hash: desiredInstallStateHash }, null, 2)}\n`, "utf-8");
 }
 async function initializeWorkspaceDirectory() {
     const workspaceDir = getWorkspaceDirFromEnv();

package/dist/workspace_files/.opencode/plugins/apply-patch-session-diff.ts

@@ -0,0 +1,343 @@
+import fs from "node:fs"
+import path from "node:path"
+import type { Plugin } from "@opencode-ai/plugin"
+
+function getApiBaseUrl(): string {
+  const port = process.env.TEAMCOPILOT_PORT?.trim()
+  if (!port) {
+    throw new Error("TEAMCOPILOT_PORT must be set.")
+  }
+  return `http://localhost:${port}`
+}
+
+interface SessionLookupResponse {
+  error?: unknown
+  data?: {
+    id?: string
+    parentID?: string
+  }
+}
+
+type ToolArgs = Record<string, unknown> | undefined
+
+function findPatchPayload(value: unknown): string | null {
+  if (typeof value === "string") {
+    const normalized = value.replace(/\r\n/g, "\n")
+    if (normalized.includes("*** Begin Patch")) {
+      return normalized
+    }
+    return null
+  }
+
+  if (!value || typeof value !== "object") {
+    return null
+  }
+
+  for (const nestedValue of Object.values(value as Record<string, unknown>)) {
+    const match = findPatchPayload(nestedValue)
+    if (match) {
+      return match
+    }
+  }
+
+  return null
+}
+
+function extractTrackedPathsFromPatch(patchText: string): string[] {
+  const normalized = patchText.replace(/\r\n/g, "\n")
+  const fileHeaderMatches = normalized.matchAll(/^\s*\*\*\* (?:Add|Update|Delete) File: (.+)$/gm)
+  const paths = Array.from(fileHeaderMatches, (match) => match[1].trim()).filter(
+    (candidate) => candidate.length > 0
+  )
+
+  if (paths.length === 0) {
+    throw new Error("Could not determine target path from apply_patch payload.")
+  }
+
+  const moveToMatches = normalized.matchAll(/^\s*\*\*\* Move to: (.+)$/gm)
+  for (const match of moveToMatches) {
+    const targetPath = match[1].trim()
+    if (targetPath.length > 0) {
+      paths.push(targetPath)
+    }
+  }
+
+  return Array.from(new Set(paths.filter((candidate) => candidate.length > 0)))
+}
+
+function findNestedStringByKeys(value: unknown, keys: Set<string>): string | null {
+  if (!value || typeof value !== "object") {
+    return null
+  }
+
+  for (const [key, nestedValue] of Object.entries(value as Record<string, unknown>)) {
+    if (keys.has(key) && typeof nestedValue === "string" && nestedValue.trim().length > 0) {
+      return nestedValue
+    }
+
+    const nestedMatch = findNestedStringByKeys(nestedValue, keys)
+    if (nestedMatch) {
+      return nestedMatch
+    }
+  }
+
+  return null
+}
+
+function tokenizeCommand(command: string): string[] {
+  const tokens = command.match(/"[^"]*"|'[^']*'|&&|\|\||[;|]|[^\s]+/g) ?? []
+  return tokens.map((token) => {
+    if (
+      (token.startsWith("\"") && token.endsWith("\"")) ||
+      (token.startsWith("'") && token.endsWith("'"))
+    ) {
+      return token.slice(1, -1)
+    }
+
+    return token
+  })
+}
+
+const CONTROL_TOKENS = new Set(["&&", "||", ";", "|"])
+
+function resolveExecutionDirectory(rawCwd: unknown, fallbackDirectory: string): string {
+  if (typeof rawCwd !== "string" || rawCwd.trim() === "") {
+    return fallbackDirectory
+  }
+
+  return path.isAbsolute(rawCwd) ? rawCwd : path.resolve(fallbackDirectory, rawCwd)
+}
+
+function resolveTrackedDeleteTargets(command: string, executionDirectory: string): string[] {
+  const tokens = tokenizeCommand(command.trim())
+  if (tokens.length === 0) {
+    return []
+  }
+
+  const resolvedTargets: string[] = []
+  let currentDirectory = executionDirectory
+  let index = 0
+  let atCommandStart = true
+
+  while (index < tokens.length) {
+    const token = tokens[index]
+
+    if (CONTROL_TOKENS.has(token)) {
+      atCommandStart = true
+      index += 1
+      continue
+    }
+
+    if (!atCommandStart) {
+      index += 1
+      continue
+    }
+
+    if (token === "cd") {
+      const destination = tokens[index + 1]
+      if (destination && !CONTROL_TOKENS.has(destination)) {
+        currentDirectory = path.isAbsolute(destination)
+          ? path.resolve(destination)
+          : path.resolve(currentDirectory, destination)
+        index += 2
+      } else {
+        index += 1
+      }
+      atCommandStart = false
+      continue
+    }
+
+    if (path.basename(token) === "rm") {
+      index += 1
+      while (index < tokens.length && !CONTROL_TOKENS.has(tokens[index])) {
+        const candidate = tokens[index]
+        if (candidate === "--" || candidate.startsWith("-")) {
+          index += 1
+          continue
+        }
+
+        const resolvedCandidate = path.isAbsolute(candidate)
+          ? path.resolve(candidate)
+          : path.resolve(currentDirectory, candidate)
+        if (fs.existsSync(resolvedCandidate) && fs.statSync(resolvedCandidate).isDirectory()) {
+          index += 1
+          continue
+        }
+        resolvedTargets.push(resolvedCandidate)
+        index += 1
+      }
+      atCommandStart = false
+      continue
+    }
+
+    atCommandStart = false
+    index += 1
+  }
+
+  return Array.from(new Set(resolvedTargets))
+}
+
+function normalizeRelativePath(rawPath: string, workspaceDir: string): string {
+  const trimmed = rawPath.trim()
+  if (!trimmed) {
+    throw new Error("apply_patch hook received an empty file path.")
+  }
+
+  const resolvedPath = path.isAbsolute(trimmed)
+    ? path.resolve(trimmed)
+    : path.resolve(workspaceDir, trimmed)
+  const relativePath = path.relative(workspaceDir, resolvedPath)
+
+  if (relativePath.startsWith("..") || path.isAbsolute(relativePath)) {
+    throw new Error(`apply_patch path '${trimmed}' is outside the workspace.`)
+  }
+
+  return relativePath.split(path.sep).join("/")
+}
+
+function tryNormalizeRelativePath(rawPath: string, workspaceDir: string): string | null {
+  try {
+    return normalizeRelativePath(rawPath, workspaceDir)
+  } catch {
+    return null
+  }
+}
+
+async function readErrorMessageFromResponse(
+  response: Response,
+  fallbackMessage: string
+): Promise<string> {
+  try {
+    const text = await response.text()
+    if (!text) return fallbackMessage
+    try {
+      const parsed: unknown = JSON.parse(text)
+      if (parsed && typeof parsed === "object" && "message" in parsed) {
+        const message = (parsed as { message?: unknown }).message
+        if (typeof message === "string" && message.trim().length > 0) {
+          return message
+        }
+      }
+    } catch {
+      // Fall back to plain text.
+    }
+    return text.trim().length > 0 ? text : fallbackMessage
+  } catch {
+    return fallbackMessage
+  }
+}
+
+function collectTrackedPathsForTool(
+  tool: string,
+  inputArgs: ToolArgs,
+  outputArgs: ToolArgs,
+  workspaceDir: string
+): string[] {
+  if (tool === "apply_patch") {
+    const patchPayload = findPatchPayload(outputArgs) ?? findPatchPayload(inputArgs)
+    if (!patchPayload) {
+      return []
+    }
+
+    return extractTrackedPathsFromPatch(patchPayload)
+  }
+
+  if (tool === "write") {
+    const filepath =
+      findNestedStringByKeys(outputArgs, new Set(["filepath", "filePath"])) ??
+      findNestedStringByKeys(inputArgs, new Set(["filepath", "filePath"]))
+    if (!filepath) {
+      return []
+    }
+
+    return [filepath]
+  }
+
+  if (tool === "bash") {
+    const command =
+      findNestedStringByKeys(outputArgs, new Set(["command", "cmd", "script", "arguments"])) ??
+      findNestedStringByKeys(inputArgs, new Set(["command", "cmd", "script", "arguments"]))
+    if (!command) {
+      return []
+    }
+
+    const rawCwd =
+      (outputArgs && (outputArgs.workdir ?? outputArgs.cwd)) ??
+      (inputArgs && (inputArgs.workdir ?? inputArgs.cwd))
+    const executionDirectory = resolveExecutionDirectory(rawCwd, workspaceDir)
+
+    return resolveTrackedDeleteTargets(command, executionDirectory)
+  }
+
+  return []
+}
+
+export const ApplyPatchSessionDiffPlugin: Plugin = async ({ client, directory }) => {
+  async function resolveRootSessionID(sessionID: string): Promise<string> {
+    let currentSessionID = sessionID
+
+    while (true) {
+      const response = (await client.session.get({
+        path: {
+          id: currentSessionID,
+        },
+      })) as SessionLookupResponse
+      if (response.error) {
+        throw new Error(`Failed to resolve root session for ${currentSessionID}`)
+      }
+
+      const parentID = response.data?.parentID
+      if (!parentID) {
+        return currentSessionID
+      }
+
+      currentSessionID = parentID
+    }
+  }
+
+  async function captureBaselineForPath(sessionID: string, relativePath: string): Promise<void> {
+    const response = await fetch(`${getApiBaseUrl()}/api/chat/sessions/file-diff/capture-baseline`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${sessionID}`,
+      },
+      body: JSON.stringify({
+        path: relativePath,
+      }),
+    })
+
+    if (!response.ok) {
+      const errorMessage = await readErrorMessageFromResponse(
+        response,
+        `Failed to capture file baseline for ${relativePath} (HTTP ${response.status})`
+      )
+      throw new Error(errorMessage)
+    }
+  }
+
+  return {
+    "tool.execute.before": async (input, output) => {
+      if (!["apply_patch", "write", "bash"].includes(input.tool)) {
+        return
+      }
+
+      const rawSessionID = typeof input.sessionID === "string" ? input.sessionID.trim() : ""
+      if (!rawSessionID) {
+        return
+      }
+
+      const rootSessionID = await resolveRootSessionID(rawSessionID)
+      const paths = collectTrackedPathsForTool(input.tool, input.args, output.args, directory)
+      for (const candidatePath of paths) {
+        const relativePath = tryNormalizeRelativePath(candidatePath, directory)
+        if (!relativePath) {
+          continue
+        }
+        await captureBaselineForPath(rootSessionID, relativePath)
+      }
+    },
+  }
+}
+
+export default ApplyPatchSessionDiffPlugin

package/dist/workspace_files/package.json

@@ -4,4 +4,4 @@
   },
   "devDependencies": {},
   "scripts": {}
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teamcopilot",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "A shared AI Agent for Teams",
   "homepage": "https://teamcopilot.ai",
   "repository": {