@ultrst-armada/kloks 1.6.0 → 1.7.1

package/packages/backend/dist/{chunk-J2J24JVC.js → chunk-R45CEV46.js}

@@ -143,9 +143,9 @@ var LocalFSAdapter = class extends BaseStorageAdapter {
 async function ensureS3DirectoryMarker(s3, bucketName, folderPrefix) {
   const clean = folderPrefix.replace(/^\/+|\/+$/g, "");
   if (!clean) return;
-  const { PutObjectCommand: PutObjectCommand3 } = await import("@aws-sdk/client-s3");
+  const { PutObjectCommand: PutObjectCommand2 } = await import("@aws-sdk/client-s3");
   try {
-    await s3.send(new PutObjectCommand3({
+    await s3.send(new PutObjectCommand2({
       Bucket: bucketName,
       Key: `${clean}/`,
       Body: Buffer.alloc(0),
@@ -197,7 +197,7 @@ async function permanentDeleteS3Folder(s3, bucketName, targetPrefix) {
   const bare = targetPrefix.replace(/\/+$/, "");
   const isMatch = (k) => k === bare || k === `${bare}/` || k.startsWith(`${bare}/`);
   try {
-    const { ListObjectVersionsCommand, DeleteObjectsCommand, DeleteObjectCommand, ListObjectsV2Command: ListObjectsV2Command3 } = await import("@aws-sdk/client-s3");
+    const { ListObjectVersionsCommand, DeleteObjectsCommand, DeleteObjectCommand, ListObjectsV2Command: ListObjectsV2Command2 } = await import("@aws-sdk/client-s3");
     let keyMarker;
     let versionMarker;
     let isTruncated = true;
@@ -237,7 +237,7 @@ async function permanentDeleteS3Folder(s3, bucketName, targetPrefix) {
     let contToken;
     let more = true;
     while (more) {
-      const v2Res = await s3.send(new ListObjectsV2Command3({ Bucket: bucketName, Prefix: bare, ContinuationToken: contToken }));
+      const v2Res = await s3.send(new ListObjectsV2Command2({ Bucket: bucketName, Prefix: bare, ContinuationToken: contToken }));
       for (const obj of v2Res.Contents || []) {
         if (obj.Key && isMatch(obj.Key)) {
           await permanentDeleteS3Object(s3, bucketName, obj.Key);
@@ -262,12 +262,12 @@ async function renameS3Folder(s3, bucketName, oldPrefix, newPrefix) {
   const newDir = `${newClean}/`;
   let movedCount = 0;
   try {
-    const { ListObjectsV2Command: ListObjectsV2Command3, GetObjectCommand: GetObjectCommand3, PutObjectCommand: PutObjectCommand3 } = await import("@aws-sdk/client-s3");
+    const { ListObjectsV2Command: ListObjectsV2Command2, GetObjectCommand: GetObjectCommand2, PutObjectCommand: PutObjectCommand2 } = await import("@aws-sdk/client-s3");
     let contToken;
     let more = true;
     const items = [];
     while (more) {
-      const res = await s3.send(new ListObjectsV2Command3({ Bucket: bucketName, Prefix: oldFolderKey, ContinuationToken: contToken }));
+      const res = await s3.send(new ListObjectsV2Command2({ Bucket: bucketName, Prefix: oldFolderKey, ContinuationToken: contToken }));
       for (const obj of res.Contents || []) {
         if (!obj.Key) continue;
         if (obj.Key === oldFolderKey || obj.Key === oldDir) items.push({ Key: obj.Key, isDir: true, subRel: "" });
@@ -283,10 +283,10 @@ async function renameS3Folder(s3, bucketName, oldPrefix, newPrefix) {
         continue;
       }
       const newKey = `${newDir}${item.subRel}`;
-      const getRes = await s3.send(new GetObjectCommand3({ Bucket: bucketName, Key: item.Key }));
+      const getRes = await s3.send(new GetObjectCommand2({ Bucket: bucketName, Key: item.Key }));
       if (getRes.Body) {
         const bytes = await getRes.Body.transformToByteArray();
-        await s3.send(new PutObjectCommand3({ Bucket: bucketName, Key: newKey, Body: bytes, ContentType: getRes.ContentType || "application/octet-stream" }));
+        await s3.send(new PutObjectCommand2({ Bucket: bucketName, Key: newKey, Body: bytes, ContentType: getRes.ContentType || "application/octet-stream" }));
         movedCount++;
       }
     }
@@ -298,129 +298,6 @@ async function renameS3Folder(s3, bucketName, oldPrefix, newPrefix) {
   }
 }
 
-// src/storage/S3Adapter.ts
-var S3Client;
-var PutObjectCommand;
-var GetObjectCommand;
-var ListObjectsV2Command;
-var HeadObjectCommand;
-var S3Adapter = class extends BaseStorageAdapter {
-  client;
-  bucket;
-  constructor(config) {
-    super(config);
-    this.bucket = config.bucket || "";
-  }
-  async ensureClient() {
-    if (this.client) return;
-    try {
-      const aws = await import("@aws-sdk/client-s3");
-      S3Client = aws.S3Client;
-      PutObjectCommand = aws.PutObjectCommand;
-      GetObjectCommand = aws.GetObjectCommand;
-      ListObjectsV2Command = aws.ListObjectsV2Command;
-      HeadObjectCommand = aws.HeadObjectCommand;
-      this.client = new S3Client({
-        region: this.config.region || "us-east-1",
-        endpoint: this.config.endpoint,
-        credentials: {
-          accessKeyId: this.config.accessKey,
-          secretAccessKey: this.config.secretKey
-        },
-        forcePathStyle: Boolean(this.config.endpoint)
-      });
-    } catch (e) {
-      throw new Error(`@aws-sdk/client-s3 failed to initialize: ${e.message}`);
-    }
-  }
-  async read(pathStr) {
-    await this.ensureClient();
-    const command = new GetObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
-    const response = await this.client.send(command);
-    return response.Body ? await response.Body.transformToByteArray() : new Uint8Array();
-  }
-  async write(pathStr, data, contentType = "application/octet-stream") {
-    await this.ensureClient();
-    const body = typeof data === "string" ? Buffer.from(data, "utf-8") : Buffer.from(data);
-    const command = new PutObjectCommand({
-      Bucket: this.bucket,
-      Key: this.normalizePath(pathStr),
-      Body: body,
-      ContentType: contentType
-    });
-    await this.client.send(command);
-  }
-  async delete(pathStr) {
-    await this.ensureClient();
-    await permanentDeleteS3Object(this.client, this.bucket, this.normalizePath(pathStr));
-  }
-  async deleteFolder(pathStr) {
-    await this.ensureClient();
-    return await permanentDeleteS3Folder(this.client, this.bucket, this.normalizePath(pathStr));
-  }
-  async renameFolder(oldPath, newPath) {
-    await this.ensureClient();
-    return await renameS3Folder(this.client, this.bucket, this.normalizePath(oldPath), this.normalizePath(newPath));
-  }
-  async ensureDirectory(pathStr) {
-    await this.ensureClient();
-    await ensureS3DirectoryMarker(this.client, this.bucket, this.normalizePath(pathStr));
-  }
-  async exists(pathStr) {
-    await this.ensureClient();
-    try {
-      const command = new HeadObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
-      await this.client.send(command);
-      return true;
-    } catch (e) {
-      if (e.name === "NotFound" || e.$metadata?.httpStatusCode === 404) return false;
-      throw e;
-    }
-  }
-  async list(pathStr = "") {
-    await this.ensureClient();
-    const prefix = pathStr ? this.normalizePath(pathStr).replace(/\/+$/, "") + "/" : "";
-    const command = new ListObjectsV2Command({ Bucket: this.bucket, Prefix: prefix });
-    const response = await this.client.send(command);
-    return (response.Contents || []).map((item) => ({
-      path: item.Key,
-      size: item.Size || 0,
-      modifiedAt: item.LastModified ? item.LastModified.getTime() : 0
-    }));
-  }
-  async stat(pathStr) {
-    await this.ensureClient();
-    const command = new HeadObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
-    const response = await this.client.send(command);
-    return {
-      path: pathStr,
-      size: response.ContentLength || 0,
-      modifiedAt: response.LastModified ? response.LastModified.getTime() : 0
-    };
-  }
-  async mkdir(pathStr) {
-    await this.ensureDirectory(pathStr);
-  }
-  async testConnection() {
-    const start = performance.now();
-    try {
-      await this.ensureClient();
-      const res = await this.client.send(new ListObjectsV2Command({ Bucket: this.bucket, MaxKeys: 1 }));
-      return {
-        ok: true,
-        latencyMs: Math.round(performance.now() - start),
-        details: { bucket: this.bucket, keyCount: res.KeyCount ?? 0 }
-      };
-    } catch (e) {
-      return {
-        ok: false,
-        latencyMs: Math.round(performance.now() - start),
-        error: e.message
-      };
-    }
-  }
-};
-
 // src/storage/b2Endpoint.ts
 function isSecretMasked(str) {
   return Boolean(str && (str.includes("\u2022") || str.includes("***")));
@@ -486,11 +363,11 @@ ${appKey}`;
 }
 
 // src/storage/BackblazeB2Adapter.ts
-var S3Client2;
-var PutObjectCommand2;
-var GetObjectCommand2;
-var ListObjectsV2Command2;
-var HeadObjectCommand2;
+var S3Client;
+var PutObjectCommand;
+var GetObjectCommand;
+var ListObjectsV2Command;
+var HeadObjectCommand;
 var BackblazeB2Adapter = class extends BaseStorageAdapter {
   client;
   bucket;
@@ -502,17 +379,17 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
     if (this.client) return;
     try {
       const aws = await import("@aws-sdk/client-s3");
-      S3Client2 = aws.S3Client;
-      PutObjectCommand2 = aws.PutObjectCommand;
-      GetObjectCommand2 = aws.GetObjectCommand;
-      ListObjectsV2Command2 = aws.ListObjectsV2Command;
-      HeadObjectCommand2 = aws.HeadObjectCommand;
+      S3Client = aws.S3Client;
+      PutObjectCommand = aws.PutObjectCommand;
+      GetObjectCommand = aws.GetObjectCommand;
+      ListObjectsV2Command = aws.ListObjectsV2Command;
+      HeadObjectCommand = aws.HeadObjectCommand;
       const rawKeyId = this.config.b2KeyId || this.config.accessKey || this.config.keyId;
       const rawAppKey = this.config.b2ApplicationKey || this.config.secretKey || this.config.applicationKey;
       const { keyId, appKey } = normalizeBackblazeCredentials(rawKeyId, rawAppKey);
       const rawEndpoint = this.config.b2Endpoint || this.config.endpoint || this.config.b2Region || this.config.region;
       const { endpoint, region } = resolveBackblazeEndpoint(rawEndpoint, keyId);
-      this.client = new S3Client2({
+      this.client = new S3Client({
         region,
         endpoint,
         forcePathStyle: true,
@@ -527,14 +404,14 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
   }
   async read(pathStr) {
     await this.ensureClient();
-    const command = new GetObjectCommand2({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
+    const command = new GetObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
     const response = await this.client.send(command);
     return response.Body ? await response.Body.transformToByteArray() : new Uint8Array();
   }
   async write(pathStr, data, contentType = "text/plain") {
     await this.ensureClient();
     const body = typeof data === "string" ? Buffer.from(data, "utf-8") : Buffer.from(data);
-    const command = new PutObjectCommand2({
+    const command = new PutObjectCommand({
       Bucket: this.bucket,
       Key: this.normalizePath(pathStr),
       Body: body,
@@ -566,7 +443,7 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
   async exists(pathStr) {
     await this.ensureClient();
     try {
-      const command = new HeadObjectCommand2({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
+      const command = new HeadObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
       await this.client.send(command);
       return true;
     } catch (e) {
@@ -577,7 +454,7 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
   async list(pathStr = "") {
     await this.ensureClient();
     const prefix = pathStr ? this.normalizePath(pathStr).replace(/\/+$/, "") + "/" : "";
-    const command = new ListObjectsV2Command2({ Bucket: this.bucket, Prefix: prefix });
+    const command = new ListObjectsV2Command({ Bucket: this.bucket, Prefix: prefix });
     const response = await this.client.send(command);
     return (response.Contents || []).map((item) => ({
       path: item.Key,
@@ -587,7 +464,7 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
   }
   async stat(pathStr) {
     await this.ensureClient();
-    const command = new HeadObjectCommand2({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
+    const command = new HeadObjectCommand({ Bucket: this.bucket, Key: this.normalizePath(pathStr) });
     const response = await this.client.send(command);
     return {
       path: pathStr,
@@ -602,7 +479,7 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
     const start = performance.now();
     try {
       await this.ensureClient();
-      const res = await this.client.send(new ListObjectsV2Command2({ Bucket: this.bucket, MaxKeys: 1 }));
+      const res = await this.client.send(new ListObjectsV2Command({ Bucket: this.bucket, MaxKeys: 1 }));
       return {
         ok: true,
         latencyMs: Math.round(performance.now() - start),
@@ -618,6 +495,185 @@ var BackblazeB2Adapter = class extends BaseStorageAdapter {
   }
 };
 
+// src/storage/GoogleDriveOAuth.ts
+var AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+function createGoogleDriveAuthorizationUrl(config, state, codeChallenge) {
+  const params = new URLSearchParams({
+    client_id: config.clientId,
+    redirect_uri: config.redirectUri,
+    response_type: "code",
+    access_type: "offline",
+    prompt: "consent",
+    scope: (config.scopes || ["https://www.googleapis.com/auth/drive.file"]).join(" "),
+    state
+  });
+  if (codeChallenge) {
+    params.set("code_challenge", codeChallenge);
+    params.set("code_challenge_method", "S256");
+  }
+  return `${AUTH_URL}?${params.toString()}`;
+}
+async function exchangeGoogleDriveCode(config, code, codeVerifier) {
+  const body = new URLSearchParams({
+    client_id: config.clientId,
+    redirect_uri: config.redirectUri,
+    code,
+    grant_type: "authorization_code"
+  });
+  if (config.clientSecret) body.set("client_secret", config.clientSecret);
+  if (codeVerifier) body.set("code_verifier", codeVerifier);
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!response.ok) throw new Error(`Google OAuth token exchange failed: ${response.status}`);
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: data.expires_in ? Date.now() + Number(data.expires_in) * 1e3 : void 0,
+    tokenType: data.token_type
+  };
+}
+async function refreshGoogleDriveAccessToken(clientId, refreshToken) {
+  const body = new URLSearchParams({
+    client_id: clientId,
+    refresh_token: refreshToken,
+    grant_type: "refresh_token"
+  });
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+  if (!response.ok) throw new Error(`Google OAuth refresh failed: ${response.status}`);
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    expiresAt: data.expires_in ? Date.now() + Number(data.expires_in) * 1e3 : void 0,
+    tokenType: data.token_type
+  };
+}
+
+// src/storage/GoogleDriveAdapter.ts
+var GoogleDriveAdapter = class extends BaseStorageAdapter {
+  async token() {
+    const accessToken = this.config.googleAccessToken || this.config.accessKey;
+    const expiresAt = Number(this.config.googleAccessTokenExpiresAt || 0);
+    if (accessToken && (!expiresAt || expiresAt > Date.now() + 6e4)) return accessToken;
+    const refreshToken = this.config.googleRefreshToken;
+    const clientId = this.config.googleClientId;
+    if (!refreshToken || !clientId) throw new Error("Google Drive OAuth credentials are incomplete.");
+    const refreshed = await refreshGoogleDriveAccessToken(clientId, refreshToken);
+    this.config.googleAccessToken = refreshed.accessToken;
+    this.config.googleAccessTokenExpiresAt = refreshed.expiresAt;
+    return refreshed.accessToken;
+  }
+  async request(url, init = {}) {
+    const headers = new Headers(init.headers);
+    headers.set("Authorization", `Bearer ${await this.token()}`);
+    return fetch(url, { ...init, headers });
+  }
+  async findChild(parentId, name) {
+    const q = `'${parentId}' in parents and name = '${name.replace(/'/g, "\\'")}' and trashed = false`;
+    const res = await this.request(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(q)}&fields=files(id,name,size,modifiedTime,mimeType)&pageSize=10`);
+    if (!res.ok) throw new Error(`Google Drive lookup failed: ${res.status}`);
+    const data = await res.json();
+    return data.files?.[0] || null;
+  }
+  async resolveParent(relativeDir, create = false) {
+    let parent = this.config.googleRootFolderId || this.config.rootFolderId || "root";
+    for (const part of this.normalizePath(relativeDir).split("/").filter(Boolean)) {
+      let child = await this.findChild(parent, part);
+      if (!child && create) {
+        const res = await this.request("https://www.googleapis.com/drive/v3/files", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ name: part, mimeType: "application/vnd.google-apps.folder", parents: [parent] })
+        });
+        if (!res.ok) throw new Error(`Google Drive folder creation failed: ${res.status}`);
+        child = await res.json();
+      }
+      if (!child) throw new Error(`Google Drive directory not found: ${part}`);
+      parent = child.id;
+    }
+    return parent;
+  }
+  split(pathStr) {
+    const key = this.normalizePath(pathStr);
+    const i = key.lastIndexOf("/");
+    return i < 0 ? { dir: "", name: key } : { dir: key.slice(0, i), name: key.slice(i + 1) };
+  }
+  async read(pathStr) {
+    const { dir, name } = this.split(pathStr);
+    const parent = await this.resolveParent(dir);
+    const file = await this.findChild(parent, name);
+    if (!file) throw new Error(`Google Drive file not found: ${pathStr}`);
+    const res = await this.request(`https://www.googleapis.com/drive/v3/files/${file.id}?alt=media`);
+    if (!res.ok) throw new Error(`Google Drive download failed: ${res.status}`);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  async write(pathStr, data, contentType = "application/octet-stream") {
+    const { dir, name } = this.split(pathStr);
+    const parent = await this.resolveParent(dir, true);
+    const existing = await this.findChild(parent, name);
+    const bytes = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    const form = new FormData();
+    form.append("metadata", new Blob([JSON.stringify({ name, mimeType: contentType, ...existing ? {} : { parents: [parent] } })], { type: "application/json" }));
+    form.append("file", new Blob([bytes], { type: contentType }));
+    const url = existing ? `https://www.googleapis.com/upload/drive/v3/files/${existing.id}?uploadType=multipart` : "https://www.googleapis.com/upload/drive/v3/files?uploadType=multipart";
+    const res = await this.request(url, { method: existing ? "PATCH" : "POST", body: form });
+    if (!res.ok) throw new Error(`Google Drive upload failed: ${res.status}`);
+  }
+  async delete(pathStr) {
+    const { dir, name } = this.split(pathStr);
+    const parent = await this.resolveParent(dir);
+    const file = await this.findChild(parent, name);
+    if (!file) return;
+    const res = await this.request(`https://www.googleapis.com/drive/v3/files/${file.id}`, { method: "DELETE" });
+    if (!res.ok && res.status !== 404) throw new Error(`Google Drive delete failed: ${res.status}`);
+  }
+  async exists(pathStr) {
+    try {
+      await this.stat(pathStr);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async list(pathStr = "") {
+    const parent = await this.resolveParent(pathStr);
+    const q = `'${parent}' in parents and trashed = false`;
+    const res = await this.request(`https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(q)}&fields=files(id,name,size,modifiedTime,mimeType)&pageSize=1000`);
+    if (!res.ok) throw new Error(`Google Drive list failed: ${res.status}`);
+    const data = await res.json();
+    return (data.files || []).map((f) => ({ path: this.normalizePath(pathStr ? `${pathStr}/${f.name}` : f.name), size: Number(f.size || 0), modifiedAt: f.modifiedTime ? Date.parse(f.modifiedTime) : 0 }));
+  }
+  async stat(pathStr) {
+    const { dir, name } = this.split(pathStr);
+    const parent = await this.resolveParent(dir);
+    const file = await this.findChild(parent, name);
+    if (!file) throw new Error(`Google Drive file not found: ${pathStr}`);
+    return { path: pathStr, size: Number(file.size || 0), modifiedAt: file.modifiedTime ? Date.parse(file.modifiedTime) : 0 };
+  }
+  async mkdir(pathStr) {
+    await this.resolveParent(pathStr, true);
+  }
+  async testConnection() {
+    const start = performance.now();
+    try {
+      const res = await this.request("https://www.googleapis.com/drive/v3/about?fields=user");
+      if (!res.ok) throw new Error(`Google Drive authorization failed: ${res.status}`);
+      const data = await res.json();
+      return { ok: true, latencyMs: Math.round(performance.now() - start), details: { email: data.user?.emailAddress } };
+    } catch (e) {
+      return { ok: false, latencyMs: Math.round(performance.now() - start), error: e.message };
+    }
+  }
+};
+
 // src/storage/SupabaseStorageAdapter.ts
 var createClient;
 var SupabaseStorageAdapter = class extends BaseStorageAdapter {
@@ -699,15 +755,13 @@ var StorageAdapterFactory = class {
     switch (config.provider) {
       case "local_fs":
         return new LocalFSAdapter(config);
-      case "s3":
-      case "cloudflare_r2":
-      case "r2":
-        return new S3Adapter(config);
       case "backblaze_b2":
       case "b2":
         return new BackblazeB2Adapter(config);
       case "supabase":
         return new SupabaseStorageAdapter(config);
+      case "google_drive":
+        return new GoogleDriveAdapter(config);
       default:
         throw new Error(`Unsupported storage provider: ${config.provider}`);
     }
@@ -721,11 +775,14 @@ export {
   permanentDeleteS3Object,
   permanentDeleteS3Folder,
   renameS3Folder,
-  S3Adapter,
   isSecretMasked,
   resolveBackblazeEndpoint,
   normalizeBackblazeCredentials,
   BackblazeB2Adapter,
+  createGoogleDriveAuthorizationUrl,
+  exchangeGoogleDriveCode,
+  refreshGoogleDriveAccessToken,
+  GoogleDriveAdapter,
   SupabaseStorageAdapter,
   StorageAdapterFactory
 };

package/packages/backend/dist/{chunk-3HZYAZF4.js → chunk-SQGBAWZN.js}

@@ -245,6 +245,7 @@ var DevelopmentServiceDefinition = createServiceDefinition({
         providers: [
           { id: "webcontainer", capabilities: ["install", "lint", "test", "build", "validate", "check", "process-host"] },
           { id: "typescript-language-server", capabilities: ["lsp", "diagnostics", "completion", "hover", "definition", "references", "rename", "symbols"] },
+          { id: "agent-harness", capabilities: ["deepseek", "openai", "google", "headless", "sdk", "acp"] },
           { id: "github-actions", capabilities: ["dispatch", "observe", "rerun", "cancel"] }
         ]
       })
@@ -301,8 +302,8 @@ var COMMANDS2 = {
 var DEFAULT_LAYERS = ["syntax", "lint", "krnl", "frnl"];
 var commandText = (command, args) => [command, ...args].join(" ");
 var CodeValidationRuntime = class {
-  constructor(runtime4 = new WebContainerRuntime()) {
-    this.runtime = runtime4;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   async validate(input = {}) {
@@ -356,8 +357,8 @@ var CodeValidationServiceFacade = {
 
 // src/development/codeDiagnosticsService.ts
 var CodeDiagnosticsService = class {
-  constructor(runtime4 = new WebContainerRuntime()) {
-    this.runtime = runtime4;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   async diagnostics(input = {}) {
@@ -375,8 +376,8 @@ var TYPESCRIPT_LANGUAGE_SERVER_VERSION = "6.0.2";
 var PACKAGE = TYPESCRIPT_LANGUAGE_SERVER_PACKAGE;
 var DEFAULT_VERSION = TYPESCRIPT_LANGUAGE_SERVER_VERSION;
 var TypeScriptLanguageServerRuntime = class {
-  constructor(runtime4 = new WebContainerRuntime()) {
-    this.runtime = runtime4;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   process = null;
@@ -502,6 +503,92 @@ var TypeScriptLanguageServerServiceFacade = {
   }
 };
 
+// src/development/agentHarnessService.ts
+var PROVIDERS = [
+  {
+    id: "deepseek",
+    name: "DeepSeek Harness",
+    package: "@deepseek-ai/dsh",
+    capabilities: ["headless", "sdk", "acp", "web"],
+    implemented: true
+  },
+  {
+    id: "openai",
+    name: "OpenAI Agents SDK",
+    package: "@openai/agents",
+    capabilities: ["agents", "tools", "handoffs", "guardrails", "sessions", "tracing"],
+    implemented: false
+  },
+  {
+    id: "google",
+    name: "Google ADK",
+    package: "@google/adk",
+    capabilities: ["agents", "tools", "multi-agent", "evaluation", "deployment"],
+    implemented: false
+  }
+];
+var AgentHarnessRuntime = class {
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
+  }
+  runtime;
+  providers() {
+    return PROVIDERS.map((provider) => ({ ...provider, capabilities: [...provider.capabilities] }));
+  }
+  async run(input) {
+    if (input.provider !== "deepseek") {
+      throw new Error(
+        `Agent harness provider "${input.provider}" is registered but not yet executable; install and register its adapter before running it.`
+      );
+    }
+    const started = Date.now();
+    const profile = input.profile ?? "headless";
+    const command = "pnpm";
+    const args = ["exec", "dsh", "--profile", profile, input.prompt];
+    const result = await this.runtime.runCommand(command, args, input.cwd ?? ".", input.env);
+    return {
+      provider: input.provider,
+      ok: result.exitCode === 0,
+      exitCode: result.exitCode,
+      output: result.output,
+      durationMs: Date.now() - started,
+      command: [command, ...args].join(" ")
+    };
+  }
+};
+var runtime4 = new AgentHarnessRuntime();
+var AgentHarnessServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.agentHarness",
+  name: "AgentHarnessService",
+  version: "1.0.0",
+  operations: {
+    providers: {
+      id: "AgentHarnessService.providers",
+      name: "providers",
+      handler: async () => runtime4.providers()
+    },
+    run: {
+      id: "AgentHarnessService.run",
+      name: "run",
+      handler: async (input) => runtime4.run(input)
+    }
+  }
+});
+var AgentHarnessServiceFacade = {
+  id: AgentHarnessServiceDefinition.id,
+  name: AgentHarnessServiceDefinition.name,
+  version: AgentHarnessServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: AgentHarnessServiceDefinition,
+  createInstance: () => createService(AgentHarnessServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(AgentHarnessServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
 export {
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
@@ -521,5 +608,8 @@ export {
   TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
   TYPESCRIPT_LANGUAGE_SERVER_VERSION,
   TypeScriptLanguageServerServiceDefinition,
-  TypeScriptLanguageServerServiceFacade
+  TypeScriptLanguageServerServiceFacade,
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade
 };