@ultrst-armada/kloks 1.5.2 → 1.7.0

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

@@ -169,6 +169,10 @@ var WebContainerRuntime = class {
       release();
     }
   }
+  async spawnCommand(command, args = [], cwd, env) {
+    const container = await this.boot();
+    return container.spawn(command, args, { cwd, env });
+  }
   async teardown() {
     const container = this.container;
     this.container = null;
@@ -239,7 +243,9 @@ var DevelopmentServiceDefinition = createServiceDefinition({
       name: "describeProviders",
       handler: async () => ({
         providers: [
-          { id: "webcontainer", capabilities: ["install", "lint", "test", "build", "validate", "check"] },
+          { 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"] }
         ]
       })
@@ -296,8 +302,8 @@ var COMMANDS2 = {
 var DEFAULT_LAYERS = ["syntax", "lint", "krnl", "frnl"];
 var commandText = (command, args) => [command, ...args].join(" ");
 var CodeValidationRuntime = class {
-  constructor(runtime3 = new WebContainerRuntime()) {
-    this.runtime = runtime3;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   async validate(input = {}) {
@@ -351,8 +357,8 @@ var CodeValidationServiceFacade = {
 
 // src/development/codeDiagnosticsService.ts
 var CodeDiagnosticsService = class {
-  constructor(runtime3 = new WebContainerRuntime()) {
-    this.runtime = runtime3;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   async diagnostics(input = {}) {
@@ -364,6 +370,225 @@ var CodeDiagnosticsService = class {
 };
 var codeDiagnosticsService = new CodeDiagnosticsService();
 
+// src/development/typescriptLanguageServerService.ts
+var TYPESCRIPT_LANGUAGE_SERVER_PACKAGE = "typescript-language-server";
+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(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
+  }
+  runtime;
+  process = null;
+  writer = null;
+  pending = /* @__PURE__ */ new Map();
+  buffer = "";
+  cwd = ".";
+  version = DEFAULT_VERSION;
+  async start(input = {}) {
+    if (this.process) return this.status();
+    this.cwd = input.cwd ?? ".";
+    this.version = input.version ?? DEFAULT_VERSION;
+    if (input.install !== false) {
+      await this.runtime.runCommand("pnpm", ["add", "-D", "typescript@7.0.2", PACKAGE + "@" + this.version], this.cwd);
+    }
+    this.process = await this.runtime.spawnCommand("pnpm", ["exec", PACKAGE, "--stdio"], this.cwd);
+    this.writer = this.process.input.getWriter();
+    void this.readOutput(this.process.output);
+    return this.status();
+  }
+  async request(input) {
+    await this.ensureRunning();
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(input.id, { resolve, reject });
+    });
+    await this.write(input);
+    return promise;
+  }
+  async notify(input) {
+    await this.ensureRunning();
+    await this.write(input);
+    return { sent: true };
+  }
+  async stop() {
+    const process = this.process;
+    this.process = null;
+    this.writer?.releaseLock();
+    this.writer = null;
+    for (const pending of this.pending.values()) pending.reject(new Error("Language server stopped"));
+    this.pending.clear();
+    if (process) await process.kill();
+    return { stopped: true };
+  }
+  status() {
+    return { running: Boolean(this.process), cwd: this.cwd, package: PACKAGE, version: this.version };
+  }
+  async ensureRunning() {
+    if (!this.process) await this.start({ cwd: this.cwd, install: false, version: this.version });
+  }
+  async write(message) {
+    if (!this.writer) throw new Error("Language server input is unavailable");
+    const body = JSON.stringify({ jsonrpc: "2.0", ...message });
+    const frame = "Content-Length: " + new TextEncoder().encode(body).byteLength + "\r\n\r\n" + body;
+    await this.writer.write(frame);
+  }
+  async readOutput(output) {
+    const reader = output.getReader();
+    try {
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        this.buffer += next.value;
+        this.consumeFrames();
+      }
+    } catch (error) {
+      for (const pending of this.pending.values()) pending.reject(error instanceof Error ? error : new Error(String(error)));
+      this.pending.clear();
+    } finally {
+      reader.releaseLock();
+      this.process = null;
+      this.writer?.releaseLock();
+      this.writer = null;
+    }
+  }
+  consumeFrames() {
+    while (true) {
+      const separator = this.buffer.indexOf("\r\n\r\n");
+      if (separator < 0) return;
+      const header = this.buffer.slice(0, separator);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.slice(separator + 4);
+        continue;
+      }
+      const length = Number(match[1]);
+      const start = separator + 4;
+      if (this.buffer.length - start < length) return;
+      const body = this.buffer.slice(start, start + length);
+      this.buffer = this.buffer.slice(start + length);
+      const response = JSON.parse(body);
+      if (response.id !== void 0 && response.id !== null) {
+        this.pending.get(response.id)?.resolve(response);
+        this.pending.delete(response.id);
+      }
+    }
+  }
+};
+var runtime3 = new TypeScriptLanguageServerRuntime();
+var TypeScriptLanguageServerServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.typescriptLanguageServer",
+  name: "TypeScriptLanguageServerService",
+  version: "1.0.0",
+  operations: {
+    start: { id: "TypeScriptLanguageServerService.start", name: "start", handler: async (input) => runtime3.start(input) },
+    request: { id: "TypeScriptLanguageServerService.request", name: "request", handler: async (input) => runtime3.request(input) },
+    notify: { id: "TypeScriptLanguageServerService.notify", name: "notify", handler: async (input) => runtime3.notify(input) },
+    stop: { id: "TypeScriptLanguageServerService.stop", name: "stop", handler: async () => runtime3.stop() },
+    status: { id: "TypeScriptLanguageServerService.status", name: "status", handler: async () => runtime3.status() }
+  }
+});
+var TypeScriptLanguageServerServiceFacade = {
+  id: TypeScriptLanguageServerServiceDefinition.id,
+  name: TypeScriptLanguageServerServiceDefinition.name,
+  version: TypeScriptLanguageServerServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: TypeScriptLanguageServerServiceDefinition,
+  createInstance: () => createService(TypeScriptLanguageServerServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(TypeScriptLanguageServerServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
+// 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,
@@ -379,5 +604,12 @@ export {
   CodeValidationServiceDefinition,
   CodeValidationServiceFacade,
   CodeDiagnosticsService,
-  codeDiagnosticsService
+  codeDiagnosticsService,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade
 };

package/packages/backend/dist/chunk-VAFCR2MS.js

@@ -0,0 +1,203 @@
+// src/core/unifiedDb.ts
+var neon;
+function cleanDbUrl(url) {
+  if (!url || typeof url !== "string") return "";
+  return url.trim().replace(/^["']|["']$/g, "");
+}
+function getUnifiedDbUrl(env) {
+  const fromEnv = cleanDbUrl(env?.SYSTEM_DATABASE_URL_1) || cleanDbUrl(env?.DATABASE_URL) || cleanDbUrl(env?.SYSTEM_DATABASE_URL_2);
+  if (fromEnv) return fromEnv;
+  if (typeof process !== "undefined" && process.env) {
+    return cleanDbUrl(process.env.SYSTEM_DATABASE_URL_1) || cleanDbUrl(process.env.DATABASE_URL) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_2) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_3) || "";
+  }
+  return "";
+}
+async function queryUnifiedDb(sqlText, params = [], env) {
+  const dbUrl = getUnifiedDbUrl(env);
+  if (!dbUrl) {
+    throw new Error("[UnifiedDB] No database URL configured in environment.");
+  }
+  if (!neon) {
+    const mod = await import("@neondatabase/serverless");
+    neon = mod.neon;
+  }
+  const sql = neon(dbUrl);
+  try {
+    const rows = await (sql.query ? sql.query(sqlText, params) : sql(sqlText, params));
+    return {
+      rows: Array.isArray(rows) ? rows : [],
+      rowCount: Array.isArray(rows) ? rows.length : 0
+    };
+  } catch (err) {
+    console.error("[UnifiedDB] Query execution error:", err.message);
+    throw err;
+  }
+}
+
+// src/core/b2DirectCore.ts
+var authCache = /* @__PURE__ */ new Map();
+var bucketIdCache = /* @__PURE__ */ new Map();
+async function authorizeB2(keyId, applicationKey) {
+  const cacheKey = `${keyId.trim()}:${applicationKey.trim()}`;
+  const cached = authCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) return cached.auth;
+  const authHeader = typeof Buffer !== "undefined" ? Buffer.from(`${keyId.trim()}:${applicationKey.trim()}`).toString("base64") : btoa(`${keyId.trim()}:${applicationKey.trim()}`);
+  let res = await fetch("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", {
+    headers: { Authorization: `Basic ${authHeader}` },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) {
+    res = await fetch("https://api.backblazeb2.com/b2api/v4/b2_authorize_account", {
+      headers: { Authorization: `Basic ${authHeader}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+  }
+  if (!res.ok) {
+    const errText = await res.text();
+    throw new Error(`Backblaze B2 authorization failed (${res.status}): ${errText}`);
+  }
+  const data = await res.json();
+  const auth = {
+    accountId: data.accountId,
+    authorizationToken: data.authorizationToken,
+    apiUrl: (data.apiInfo?.storageApi?.apiUrl || data.apiUrl || "https://api.backblazeb2.com").replace(/\/+$/, ""),
+    downloadUrl: (data.apiInfo?.storageApi?.downloadUrl || data.downloadUrl || data.apiUrl || "https://f003.backblazeb2.com").replace(/\/+$/, ""),
+    s3ApiUrl: data.apiInfo?.storageApi?.s3ApiUrl || data.s3ApiUrl,
+    allowed: data.apiInfo?.storageApi?.allowed || data.allowed
+  };
+  authCache.set(cacheKey, { auth, expiresAt: Date.now() + 20 * 60 * 1e3 });
+  return auth;
+}
+async function b2ListBuckets(keyId, applicationKey, bucketId, bucketName) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const rBucketId = bucketId || auth.allowed?.bucketId || auth.allowed?.buckets?.[0]?.bucketId;
+  const rBucketName = bucketName || auth.allowed?.bucketName || auth.allowed?.buckets?.[0]?.bucketName;
+  if (!auth.allowed?.bucketId && !auth.allowed?.bucketName) {
+    try {
+      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
+        method: "POST",
+        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+        body: JSON.stringify({ accountId: auth.accountId }),
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
+      }
+    } catch (err) {
+      console.warn("[B2DirectCore] list_buckets query failed:", err.message);
+    }
+  }
+  if (rBucketId || rBucketName) {
+    const body = { accountId: auth.accountId };
+    if (rBucketId) body.bucketId = rBucketId;
+    else if (rBucketName) body.bucketName = rBucketName;
+    try {
+      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
+        method: "POST",
+        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
+      }
+    } catch {
+    }
+    return [{
+      accountId: auth.accountId,
+      bucketId: rBucketId || "restricted",
+      bucketName: rBucketName || (bucketName || "default-bucket"),
+      bucketType: "allPrivate"
+    }];
+  }
+  return [];
+}
+async function getB2BucketId(keyId, applicationKey, bucketName) {
+  const cacheKey = `${keyId.trim()}:${bucketName.trim()}`;
+  if (bucketIdCache.has(cacheKey)) return bucketIdCache.get(cacheKey);
+  const buckets = await b2ListBuckets(keyId, applicationKey, void 0, bucketName);
+  const match = buckets.find((b) => b.bucketName === bucketName);
+  if (!match) throw new Error(`B2 bucket "${bucketName}" not found in account`);
+  bucketIdCache.set(cacheKey, match.bucketId);
+  return match.bucketId;
+}
+async function b2UploadFile(keyId, applicationKey, bucketName, fileName, buffer, contentType = "b2/x-auto") {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
+  const urlRes = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_upload_url`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ bucketId })
+  });
+  if (!urlRes.ok) throw new Error(`B2 get upload url failed (${urlRes.status})`);
+  const { uploadUrl, authorizationToken } = await urlRes.json();
+  const encodedFileName = encodeURIComponent(fileName).replace(/%2F/g, "/");
+  const uploadRes = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      Authorization: authorizationToken,
+      "X-Bz-File-Name": encodedFileName,
+      "Content-Type": contentType,
+      "Content-Length": String(buffer.byteLength),
+      "X-Bz-Content-Sha1": "do_not_verify"
+    },
+    body: buffer
+  });
+  if (!uploadRes.ok) throw new Error(`B2 upload failed for ${fileName} (${uploadRes.status}): ${await uploadRes.text()}`);
+  return uploadRes.json();
+}
+async function b2DownloadFile(keyId, applicationKey, bucketName, fileName) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const encodedName = encodeURIComponent(fileName).replace(/%2F/g, "/");
+  const res = await fetch(`${auth.downloadUrl}/file/${bucketName}/${encodedName}`, { headers: { Authorization: auth.authorizationToken } });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`B2 download failed for ${fileName} (${res.status})`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+async function b2ListFileNames(keyId, applicationKey, bucketName, prefix = "") {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
+  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_file_names`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ bucketId, prefix, maxFileCount: 1e3 })
+  });
+  if (!res.ok) throw new Error(`B2 list files failed (${res.status})`);
+  const data = await res.json();
+  return data.files || [];
+}
+async function b2DeleteFileVersion(keyId, applicationKey, fileName, fileId) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_delete_file_version`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ fileName, fileId })
+  });
+  if (!res.ok) throw new Error(`B2 delete file version failed (${res.status})`);
+  return res.json();
+}
+async function b2DeleteFolder(keyId, applicationKey, bucketName, folderPrefix) {
+  const cleanPrefix = folderPrefix.replace(/\/+$/, "") + "/";
+  const files = await b2ListFileNames(keyId, applicationKey, bucketName, cleanPrefix);
+  let deletedCount = 0;
+  for (const file of files) {
+    await b2DeleteFileVersion(keyId, applicationKey, file.fileName, file.fileId);
+    deletedCount++;
+  }
+  return { success: true, deletedCount };
+}
+
+export {
+  cleanDbUrl,
+  getUnifiedDbUrl,
+  queryUnifiedDb,
+  b2ListBuckets,
+  getB2BucketId,
+  b2UploadFile,
+  b2DownloadFile,
+  b2ListFileNames,
+  b2DeleteFileVersion,
+  b2DeleteFolder
+};

package/packages/backend/dist/{chunk-GQUNN7SA.js → chunk-Y3X3H2XX.js}

@@ -1,10 +1,10 @@
 import {
   workspaceGraphService
-} from "./chunk-DBZVGMJ7.js";
+} from "./chunk-KSZ67VZJ.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
-} from "./chunk-VDROUXFT.js";
+} from "./chunk-N4Z57FVR.js";
 import {
   StorageAdapterFactory
 } from "./chunk-J2J24JVC.js";
@@ -20,9 +20,11 @@ import {
   deleteWorkspace,
   findUserWorkspace,
   getWorkspaces,
-  queryUnifiedDb,
   updateWorkspace
-} from "./chunk-E72GXBXF.js";
+} from "./chunk-6K75XXFD.js";
+import {
+  queryUnifiedDb
+} from "./chunk-VAFCR2MS.js";
 import {
   RateLimiter,
   SessionManager,

package/packages/backend/dist/development/index.d.ts

@@ -108,6 +108,7 @@ declare class WebContainerRuntime {
         exitCode: any;
         output: string;
     }>;
+    spawnCommand(command: string, args?: string[], cwd?: string, env?: Record<string, string | number | boolean>): Promise<any>;
     teardown(): Promise<{
         tornDown: boolean;
     }>;
@@ -199,4 +200,102 @@ declare class CodeDiagnosticsService {
 }
 declare const codeDiagnosticsService: CodeDiagnosticsService;
 
-export { type CodeDiagnosticsInput, type CodeDiagnosticsResult, CodeDiagnosticsService, type CodeValidationInput, type CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, type DevelopmentProvider, type DevelopmentRequest, type DevelopmentResult, DevelopmentRuntime, type DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, type DevelopmentTask, GitHubActionsClient, type GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, type ValidationDiagnostic, type ValidationLayer, type WebContainerCommand, type WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, type WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand };
+interface TypeScriptLanguageServerStartInput {
+    cwd?: string;
+    install?: boolean;
+    version?: string;
+}
+interface TypeScriptLanguageServerRequestInput {
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+interface TypeScriptLanguageServerNotificationInput {
+    method: string;
+    params?: unknown;
+}
+interface TypeScriptLanguageServerResponse {
+    jsonrpc: '2.0';
+    id?: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface TypeScriptLanguageServerStatus {
+    running: boolean;
+    cwd?: string;
+    package: string;
+    version: string;
+}
+
+declare const TYPESCRIPT_LANGUAGE_SERVER_PACKAGE = "typescript-language-server";
+declare const TYPESCRIPT_LANGUAGE_SERVER_VERSION = "6.0.2";
+declare const TypeScriptLanguageServerServiceDefinition: ServiceDefinition;
+declare const TypeScriptLanguageServerServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
+    createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
+    execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
+};
+
+type AgentHarnessProvider = 'deepseek' | 'openai' | 'google';
+interface AgentHarnessRunInput {
+    provider: AgentHarnessProvider;
+    prompt: string;
+    cwd?: string;
+    profile?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+}
+interface AgentHarnessResult {
+    provider: AgentHarnessProvider;
+    ok: boolean;
+    exitCode: number;
+    output: string;
+    durationMs: number;
+    command?: string;
+}
+interface AgentHarnessProviderInfo {
+    id: AgentHarnessProvider;
+    name: string;
+    package: string;
+    capabilities: string[];
+    implemented: boolean;
+}
+interface AgentHarnessServiceContract {
+    providers(): AgentHarnessProviderInfo[];
+    run(input: AgentHarnessRunInput): Promise<AgentHarnessResult>;
+}
+
+declare class AgentHarnessRuntime {
+    private readonly runtime;
+    constructor(runtime?: WebContainerRuntime);
+    providers(): {
+        capabilities: string[];
+        id: AgentHarnessProvider;
+        name: string;
+        package: string;
+        implemented: boolean;
+    }[];
+    run(input: AgentHarnessRunInput): Promise<AgentHarnessResult>;
+}
+declare const AgentHarnessServiceDefinition: ServiceDefinition;
+declare const AgentHarnessServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
+    createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
+    execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
+};
+
+export { type AgentHarnessProvider, type AgentHarnessProviderInfo, type AgentHarnessResult, type AgentHarnessRunInput, AgentHarnessRuntime, type AgentHarnessServiceContract, AgentHarnessServiceDefinition, AgentHarnessServiceFacade, type CodeDiagnosticsInput, type CodeDiagnosticsResult, CodeDiagnosticsService, type CodeValidationInput, type CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, type DevelopmentProvider, type DevelopmentRequest, type DevelopmentResult, DevelopmentRuntime, type DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, type DevelopmentTask, GitHubActionsClient, type GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, type TypeScriptLanguageServerNotificationInput, type TypeScriptLanguageServerRequestInput, type TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, type TypeScriptLanguageServerStartInput, type TypeScriptLanguageServerStatus, type ValidationDiagnostic, type ValidationLayer, type WebContainerCommand, type WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, type WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand };

package/packages/backend/dist/development/index.js

@@ -1,4 +1,7 @@
 import {
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade,
   CodeDiagnosticsService,
   CodeValidationRuntime,
   CodeValidationServiceDefinition,
@@ -9,14 +12,21 @@ import {
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
   GitHubActionsServiceFacade,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
   WebContainerRuntime,
   WebContainerServiceDefinition,
   WebContainerServiceFacade,
   codeDiagnosticsService,
   resolveDevelopmentCommand
-} from "../chunk-3Z7EUZWE.js";
+} from "../chunk-SQGBAWZN.js";
 import "../chunk-TY32TUNI.js";
 export {
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade,
   CodeDiagnosticsService,
   CodeValidationRuntime,
   CodeValidationServiceDefinition,
@@ -27,6 +37,10 @@ export {
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
   GitHubActionsServiceFacade,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
   WebContainerRuntime,
   WebContainerServiceDefinition,
   WebContainerServiceFacade,