teamcopilot 0.0.2 → 0.0.3

package/dist/utils/opencode-auth.js

@@ -5,14 +5,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getConfiguredModelProviderId = getConfiguredModelProviderId;
 exports.initializeOpencodeAuthStorage = initializeOpencodeAuthStorage;
+exports.isServiceManagedProvider = isServiceManagedProvider;
+exports.hasRuntimeProviderCredentials = hasRuntimeProviderCredentials;
 exports.getRuntimeProviderAuth = getRuntimeProviderAuth;
 exports.setRuntimeProviderAuth = setRuntimeProviderAuth;
+exports.syncManagedProviderConfiguration = syncManagedProviderConfiguration;
 const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const assert_1 = require("./assert");
 const workspace_sync_1 = require("./workspace-sync");
 const WORKSPACE_OPENCODE_DIR = ".opencode";
 const WORKSPACE_AUTH_FILE = "auth.json";
+const WORKSPACE_CONFIG_FILE = "opencode.json";
 const RUNTIME_DATA_HOME_DIR = "xdg-data";
 function getWorkspaceOpencodeDir() {
     return path_1.default.join((0, workspace_sync_1.getWorkspaceDirFromEnv)(), WORKSPACE_OPENCODE_DIR);
@@ -23,6 +27,9 @@ function getRuntimeDataHomePath() {
 function getRuntimeAuthPath() {
     return path_1.default.join(getRuntimeDataHomePath(), "opencode", WORKSPACE_AUTH_FILE);
 }
+function getWorkspaceOpencodeConfigPath() {
+    return path_1.default.join(getWorkspaceOpencodeDir(), WORKSPACE_CONFIG_FILE);
+}
 function normalizeProviderId(providerId) {
     return providerId.replace(/\/+$/, "");
 }
@@ -80,6 +87,35 @@ async function writeAuthRecord(filepath, data) {
     await promises_1.default.rename(tempPath, filepath);
     await promises_1.default.chmod(filepath, 0o600).catch(() => { });
 }
+async function readOpencodeConfig(filepath) {
+    try {
+        const content = await promises_1.default.readFile(filepath, "utf-8");
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error("Invalid opencode config");
+        }
+        return parsed;
+    }
+    catch (err) {
+        const nodeError = err;
+        if (nodeError.code === "ENOENT") {
+            return {
+                $schema: "https://opencode.ai/config.json",
+            };
+        }
+        throw err;
+    }
+}
+async function writeOpencodeConfig(filepath, data) {
+    await promises_1.default.mkdir(path_1.default.dirname(filepath), { recursive: true });
+    const tempPath = `${filepath}.tmp-${process.pid}-${Date.now()}`;
+    await promises_1.default.writeFile(tempPath, `${JSON.stringify(data, null, 2)}\n`, {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+    await promises_1.default.rename(tempPath, filepath);
+    await promises_1.default.chmod(filepath, 0o600).catch(() => { });
+}
 function getConfiguredModelProviderId() {
     const model = (0, assert_1.assertEnv)("OPENCODE_MODEL");
     const [providerId, ...parts] = model.split("/");
@@ -88,6 +124,14 @@ function getConfiguredModelProviderId() {
     }
     return providerId;
 }
+function getConfiguredModelId() {
+    const model = (0, assert_1.assertEnv)("OPENCODE_MODEL");
+    const [providerId, ...parts] = model.split("/");
+    if (!providerId || parts.length === 0) {
+        throw new Error("OPENCODE_MODEL must be in the format <provider>/<model>");
+    }
+    return parts.join("/");
+}
 function configureOpencodeDataHome() {
     const runtimeDataHome = getRuntimeDataHomePath();
     process.env.XDG_DATA_HOME = runtimeDataHome;
@@ -112,6 +156,40 @@ function getAuthForProvider(record, providerId) {
     const normalizedProviderId = normalizeProviderId(providerId);
     return record[providerId] || record[normalizedProviderId] || record[`${normalizedProviderId}/`];
 }
+function isAzureCustomProvider(providerId) {
+    return normalizeProviderId(providerId).toLowerCase() === "azure-openai";
+}
+function isServiceManagedProvider(providerId) {
+    return isAzureCustomProvider(providerId);
+}
+function normalizeAzureEndpoint(endpoint) {
+    return endpoint.trim().replace(/\/+$/, "");
+}
+function hasRequiredAzureEnvironment() {
+    return isNonEmptyString(process.env.AZURE_API_KEY)
+        && isNonEmptyString(process.env.AZURE_OPENAI_ENDPOINT)
+        && isNonEmptyString(process.env.AZURE_OPENAI_API_VERSION);
+}
+async function hasAzureProviderConfiguration(providerId) {
+    const deployment = getConfiguredModelId().trim();
+    const config = await readOpencodeConfig(getWorkspaceOpencodeConfigPath());
+    const provider = config.provider?.[normalizeProviderId(providerId)];
+    if (!provider || provider.npm !== "@ai-sdk/azure") {
+        return false;
+    }
+    const models = provider.models;
+    if (!models || typeof models !== "object" || Array.isArray(models)) {
+        return false;
+    }
+    const deploymentConfig = models[deployment];
+    return Boolean(deploymentConfig && typeof deploymentConfig === "object" && !Array.isArray(deploymentConfig));
+}
+async function hasRuntimeProviderCredentials(providerId) {
+    if (isAzureCustomProvider(providerId)) {
+        return hasRequiredAzureEnvironment() && await hasAzureProviderConfiguration(providerId);
+    }
+    return Boolean(await getRuntimeProviderAuth(providerId));
+}
 async function getRuntimeProviderAuth(providerId) {
     const record = await readAuthRecord(getRuntimeAuthPath());
     return getAuthForProvider(record, providerId);
@@ -124,3 +202,37 @@ async function setRuntimeProviderAuth(providerId, info) {
     runtimeRecord[normalizedProviderId] = info;
     await writeAuthRecord(getRuntimeAuthPath(), runtimeRecord);
 }
+async function syncManagedProviderConfiguration() {
+    const providerId = getConfiguredModelProviderId();
+    if (!isAzureCustomProvider(providerId) || !hasRequiredAzureEnvironment()) {
+        return;
+    }
+    const endpoint = normalizeAzureEndpoint((0, assert_1.assertEnv)("AZURE_OPENAI_ENDPOINT"));
+    const apiVersion = (0, assert_1.assertEnv)("AZURE_OPENAI_API_VERSION").trim();
+    const deployment = getConfiguredModelId().trim();
+    const normalizedProviderId = normalizeProviderId(providerId);
+    const configPath = getWorkspaceOpencodeConfigPath();
+    const configRecord = await readOpencodeConfig(configPath);
+    const providerRecord = configRecord.provider ?? {};
+    const existingProviderConfig = providerRecord[normalizedProviderId];
+    configRecord.provider = {
+        ...providerRecord,
+        [normalizedProviderId]: {
+            ...(existingProviderConfig ?? {}),
+            npm: "@ai-sdk/azure",
+            name: "Azure OpenAI",
+            models: {
+                [deployment]: {
+                    name: deployment,
+                },
+            },
+            options: {
+                ...(existingProviderConfig?.options ?? {}),
+                baseURL: `${endpoint}/openai`,
+                apiVersion,
+                useDeploymentBasedUrls: true,
+            },
+        },
+    };
+    await writeOpencodeConfig(configPath, configRecord);
+}

package/dist/utils/workspace-sync.js

@@ -21,6 +21,7 @@ const WORKSPACE_DB_DIRECTORY = ".sqlite";
 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";
 function getWorkspaceDirFromEnv() {
     let workspaceDir = (0, assert_1.assertEnv)("WORKSPACE_DIR");
     if (!path_1.default.isAbsolute(workspaceDir)) {
@@ -178,6 +179,9 @@ function syncTemplateDirectory(sourceDirectory, targetDirectory, relativePath, i
                 mergeGitignoreFile(sourceEntryPath, targetEntryPath);
                 continue;
             }
+            if (relativeEntryPath === ".opencode/opencode.json" && fs_1.default.existsSync(targetEntryPath)) {
+                continue;
+            }
             if (entry.name === "package.json") {
                 mergePackageJsonFile(sourceEntryPath, targetEntryPath);
                 continue;
@@ -195,6 +199,9 @@ async function initializeWorkspaceNodeDependencies(workspaceDir) {
         ...(existingPackageJson.dependencies ?? {}),
         "opencode-ai": "1.1.65",
     };
+    if ((0, assert_1.assertEnv)("OPENCODE_MODEL").startsWith("azure-openai/")) {
+        dependencies["@ai-sdk/azure"] = WORKSPACE_AZURE_PROVIDER_VERSION;
+    }
     const workspacePackageJson = {
         ...existingPackageJson,
         dependencies,

package/package.json

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