@rigkit/provider-vscode 0.2.1 → 0.2.3

package/dist/extension.cjs

@@ -30126,6 +30126,7 @@ function runtimeClientSchema(schema2) {
 }
 var RuntimeHandleEffectSchema = exports_Schema.Struct({
   projectId: exports_Schema.String,
+  runtimeFingerprint: exports_Schema.optional(exports_Schema.String),
   projectDir: exports_Schema.String,
   configPath: exports_Schema.String,
   statePath: exports_Schema.optional(exports_Schema.String),
@@ -30145,6 +30146,7 @@ var RuntimeReadyEffectSchema = exports_Schema.Struct({
 var RuntimeHealthEffectSchema = exports_Schema.Struct({
   ok: exports_Schema.Boolean,
   projectId: exports_Schema.String,
+  runtimeFingerprint: exports_Schema.optional(exports_Schema.String),
   projectDir: exports_Schema.optional(exports_Schema.String),
   configPath: exports_Schema.optional(exports_Schema.String),
   statePath: exports_Schema.optional(exports_Schema.String),
@@ -30175,6 +30177,7 @@ var OptionalString = exports_Schema.optional(exports_Schema.String);
 var RuntimeControlHealthEffectSchema = exports_Schema.Struct({
   ok: exports_Schema.Boolean,
   projectId: exports_Schema.String,
+  runtimeFingerprint: OptionalString,
   projectDir: exports_Schema.String,
   configPath: exports_Schema.String,
   statePath: OptionalString,
@@ -30202,14 +30205,6 @@ var RuntimeControlProjectInfoEffectSchema = exports_Schema.Struct({
   workflow: exports_Schema.optional(RuntimeControlWorkflowSummaryEffectSchema),
   workflows: exports_Schema.Array(RuntimeControlWorkflowSummaryEffectSchema)
 }).annotations({ identifier: "ProjectInfo" });
-var RuntimeControlHostMethodRequirementEffectSchema = exports_Schema.Struct({
-  id: exports_Schema.String,
-  modes: exports_Schema.optional(exports_Schema.Array(exports_Schema.String))
-}).annotations({ identifier: "HostMethodRequirement" });
-var RuntimeControlHostCapabilityRequirementEffectSchema = exports_Schema.Struct({
-  id: exports_Schema.String,
-  schemaHash: OptionalString
-}).annotations({ identifier: "HostCapabilityRequirement" });
 var RuntimeControlOperationCliEffectSchema = exports_Schema.Struct({
   positionals: exports_Schema.optional(exports_Schema.Array(exports_Schema.Struct({
     name: exports_Schema.String,
@@ -30232,21 +30227,12 @@ var RuntimeControlOperationEffectSchema = exports_Schema.Struct({
   title: exports_Schema.String,
   description: exports_Schema.String,
   createsWorkspace: exports_Schema.optional(exports_Schema.Boolean),
-  requiredHostMethods: exports_Schema.optional(exports_Schema.Array(RuntimeControlHostMethodRequirementEffectSchema)),
-  requiredHostCapabilities: exports_Schema.optional(exports_Schema.Array(RuntimeControlHostCapabilityRequirementEffectSchema)),
   cli: exports_Schema.optional(RuntimeControlOperationCliEffectSchema),
   inputSchema: UnknownRecord
 }).annotations({ identifier: "RuntimeOperation" });
 var RuntimeControlOperationsManifestEffectSchema = exports_Schema.Struct({
-  hostMethods: exports_Schema.Struct({
-    known: exports_Schema.Array(RuntimeControlHostMethodRequirementEffectSchema),
-    requiredByOperations: exports_Schema.Record({ key: exports_Schema.String, value: exports_Schema.Array(exports_Schema.String) })
-  }),
-  hostCapabilities: exports_Schema.Struct({
-    optional: exports_Schema.Array(RuntimeControlHostCapabilityRequirementEffectSchema),
-    requiredByOperations: exports_Schema.Record({ key: exports_Schema.String, value: exports_Schema.Array(exports_Schema.String) })
-  }),
-  operations: exports_Schema.Array(RuntimeControlOperationEffectSchema)
+  operations: exports_Schema.Array(RuntimeControlOperationEffectSchema),
+  workspaceOperations: exports_Schema.Array(RuntimeControlOperationEffectSchema)
 }).annotations({ identifier: "OperationsManifest" });
 var RuntimeControlWorkflowsResponseEffectSchema = exports_Schema.Struct({
   workflows: exports_Schema.Array(RuntimeControlWorkflowSummaryEffectSchema)
@@ -30254,14 +30240,8 @@ var RuntimeControlWorkflowsResponseEffectSchema = exports_Schema.Struct({
 var RuntimeControlWorkspaceEffectSchema = exports_Schema.Struct({
   id: exports_Schema.String,
   name: exports_Schema.String,
-  providerId: exports_Schema.String,
   workflow: exports_Schema.String,
-  resourceId: OptionalString,
-  snapshotId: OptionalString,
-  sourceRef: exports_Schema.Unknown,
-  context: UnknownRecord,
-  metadata: UnknownRecord,
-  data: UnknownRecord,
+  ctx: UnknownRecord,
   createdAt: exports_Schema.String,
   updatedAt: exports_Schema.String
 }).annotations({ identifier: "Workspace" });
@@ -30549,12 +30529,18 @@ async function getOrStartRuntimeUnsafe(options7) {
     statePath,
     source: options7.source
   });
+  const runtimeFingerprint = runtimeFingerprintFor({
+    projectDir,
+    configPath,
+    statePath,
+    source: options7.source
+  });
   const paths = runtimePaths(projectId, options7.rigkitHome);
-  const existing = await tryExistingRuntime(paths, projectId);
+  const existing = await tryExistingRuntime(paths, projectId, runtimeFingerprint);
   if (existing)
     return existing;
   await withRuntimeLock(paths.lockPath, async () => {
-    const secondCheck = await tryExistingRuntime(paths, projectId);
+    const secondCheck = await tryExistingRuntime(paths, projectId, runtimeFingerprint);
     if (secondCheck)
       return;
     await startRuntime({
@@ -30563,10 +30549,11 @@ async function getOrStartRuntimeUnsafe(options7) {
       configPath,
       statePath,
       projectId,
+      runtimeFingerprint,
       paths
     });
   });
-  const started = await tryExistingRuntime(paths, projectId);
+  const started = await tryExistingRuntime(paths, projectId, runtimeFingerprint);
   if (!started) {
     throw new RuntimeStartupError({
       reason: "unhealthy-after-start",
@@ -30582,12 +30569,33 @@ function projectIdFor(options7) {
   hash2.update(JSON.stringify({
     projectDir: import_node_path.resolve(options7.projectDir),
     configPath,
-    configHash: configHashFor(configPath),
     statePath: options7.statePath ? import_node_path.resolve(options7.statePath) : null,
     source: options7.source ?? null
   }));
   return `sha256-${hash2.digest("hex").slice(0, 32)}`;
 }
+function runtimeFingerprintFor(options7) {
+  const projectDir = import_node_path.resolve(options7.projectDir);
+  const configPath = import_node_path.resolve(options7.configPath);
+  const statePath = options7.statePath ? import_node_path.resolve(options7.statePath) : null;
+  const hash2 = import_node_crypto.createHash("sha256");
+  hash2.update("project\x00");
+  hash2.update(projectDir);
+  hash2.update("\x00config\x00");
+  hash2.update(configPath);
+  hash2.update("\x00state\x00");
+  hash2.update(statePath ?? "");
+  hash2.update("\x00source\x00");
+  hash2.update(JSON.stringify(options7.source ?? null));
+  updateFileFingerprint(hash2, "config", configPath);
+  for (const file2 of dotenvFilesFor(projectDir))
+    updateFileFingerprint(hash2, "dotenv", file2);
+  for (const file2 of projectFingerprintFiles(projectDir))
+    updateFileFingerprint(hash2, "project-file", file2);
+  updateProjectSurfaceFingerprint(hash2, projectDir);
+  updateRigkitPackageFingerprint(hash2, import_node_path.join(projectDir, "node_modules", "@rigkit"));
+  return `sha256-${hash2.digest("hex")}`;
+}
 function runtimePaths(projectId, rigkitHome = defaultRigkitHome()) {
   const root = import_node_path.join(rigkitHome, "runtimes");
   return {
@@ -30600,13 +30608,20 @@ function runtimePaths(projectId, rigkitHome = defaultRigkitHome()) {
 function defaultRigkitHome() {
   return process.env.RIGKIT_HOME ? import_node_path.resolve(process.env.RIGKIT_HOME) : import_node_path.join(import_node_os.homedir(), ".rigkit");
 }
-async function tryExistingRuntime(paths, projectId) {
+async function tryExistingRuntime(paths, projectId, runtimeFingerprint) {
   const handle = readHandle(paths.handlePath);
   if (!handle || handle.projectId !== projectId)
     return;
   const token = readToken(handle.tokenPath);
-  if (!token)
+  if (!token) {
+    removeStale(paths);
+    return;
+  }
+  if (handle.runtimeFingerprint !== runtimeFingerprint) {
+    await shutdownRuntime(handle, token);
+    removeStale(paths);
     return;
+  }
   try {
     const body = await createRuntimeHttpClient({ baseUrl: handle.url, token }).health();
     if (body.projectId !== projectId) {
@@ -30616,6 +30631,13 @@ async function tryExistingRuntime(paths, projectId) {
         message: `runtime project mismatch`
       });
     }
+    if (body.runtimeFingerprint !== runtimeFingerprint) {
+      throw new RuntimeConnectionError({
+        method: "GET",
+        path: "/health",
+        message: `runtime fingerprint mismatch`
+      });
+    }
     return createClient(handle, paths, token);
   } catch (error) {
     if (error instanceof RuntimeApiVersionError)
@@ -30632,6 +30654,8 @@ async function startRuntime(input) {
     "serve",
     "--project-id",
     input.projectId,
+    "--runtime-fingerprint",
+    input.runtimeFingerprint,
     "--project-dir",
     input.projectDir,
     "--config",
@@ -30783,7 +30807,7 @@ function readReadyLine(proc, paths, projectDir) {
         reason: "startup-timeout",
         projectDir,
         message: `Timed out waiting for Rigkit runtime to start`
-      }));
+      }), { kill: true });
     }, 15000);
     const cleanup = () => {
       clearTimeout(timer);
@@ -30800,11 +30824,14 @@ function readReadyLine(proc, paths, projectDir) {
       cleanup();
       resolvePromise(line);
     };
-    function fail15(error) {
+    function fail15(error, options7 = {}) {
       if (settled)
         return;
       settled = true;
       cleanup();
+      if (options7.kill)
+        killRuntimeProcess(proc);
+      removeStale(paths);
       rejectPromise(error);
     }
     function onData(chunk3) {
@@ -30839,15 +30866,100 @@ function readReadyLine(proc, paths, projectDir) {
     proc.once("exit", onExit4);
   });
 }
+function killRuntimeProcess(proc) {
+  if (!proc.pid)
+    return;
+  try {
+    proc.kill("SIGTERM");
+  } catch {}
+}
 function removeStale(paths) {
   import_node_fs.rmSync(paths.handlePath, { force: true });
 }
-function configHashFor(configPath) {
-  if (!import_node_fs.existsSync(configPath))
-    return null;
-  const hash2 = import_node_crypto.createHash("sha256");
-  hash2.update(import_node_fs.readFileSync(configPath));
-  return hash2.digest("hex");
+async function shutdownRuntime(handle, token) {
+  try {
+    await createRuntimeHttpClient({ baseUrl: handle.url, token }).shutdown();
+  } catch {
+    if (handle.pid !== process.pid) {
+      try {
+        process.kill(handle.pid);
+      } catch {}
+    }
+  }
+}
+function updateFileFingerprint(hash2, label, path) {
+  hash2.update(`\x00${label}\x00${path}\x00`);
+  if (!import_node_fs.existsSync(path)) {
+    hash2.update("missing");
+    return;
+  }
+  const stat = import_node_fs.statSync(path);
+  if (!stat.isFile()) {
+    hash2.update(`not-file:${stat.mode}`);
+    return;
+  }
+  hash2.update(import_node_fs.readFileSync(path));
+}
+function projectFingerprintFiles(projectDir) {
+  return [
+    "package.json",
+    "bun.lock",
+    "bun.lockb",
+    "pnpm-lock.yaml",
+    "package-lock.json",
+    "yarn.lock"
+  ].map((file2) => import_node_path.join(projectDir, file2));
+}
+function updateProjectSurfaceFingerprint(hash2, projectDir) {
+  if (!import_node_fs.existsSync(projectDir))
+    return;
+  const ignored = new Set([".git", ".rigkit", "node_modules", "dist", "build", ".next", ".astro"]);
+  const entries2 = import_node_fs.readdirSync(projectDir, { withFileTypes: true }).filter((entry) => !ignored.has(entry.name)).map((entry) => `${entry.name}:${entry.isDirectory() ? "dir" : entry.isFile() ? "file" : "other"}`).sort();
+  hash2.update("\x00project-surface\x00");
+  hash2.update(entries2.join(`
+`));
+}
+function updateRigkitPackageFingerprint(hash2, scopeDir) {
+  if (!import_node_fs.existsSync(scopeDir))
+    return;
+  const packageDirs = import_node_fs.readdirSync(scopeDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map((entry) => import_node_path.join(scopeDir, entry.name)).sort();
+  for (const packageDir of packageDirs) {
+    updateFileFingerprint(hash2, "rigkit-package", import_node_path.join(packageDir, "package.json"));
+    for (const file2 of collectFiles(import_node_path.join(packageDir, "src"))) {
+      updateFileFingerprint(hash2, "rigkit-source", file2);
+    }
+  }
+}
+function collectFiles(root) {
+  if (!import_node_fs.existsSync(root))
+    return [];
+  const out = [];
+  const visit = (dir) => {
+    for (const entry of import_node_fs.readdirSync(dir, { withFileTypes: true })) {
+      const path = import_node_path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        visit(path);
+      } else if (entry.isFile()) {
+        out.push(path);
+      }
+    }
+  };
+  visit(root);
+  return out.sort();
+}
+function dotenvFilesFor(projectDir) {
+  const files = [];
+  let current = projectDir;
+  while (true) {
+    const candidate = import_node_path.join(current, ".env");
+    if (import_node_fs.existsSync(candidate))
+      files.unshift(candidate);
+    const parent = import_node_path.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return files;
 }
 function isFileExistsError(error) {
   return Boolean(error && typeof error === "object" && error.code === "EEXIST");
@@ -30973,7 +31085,7 @@ function findConfigUp(startDir, fileExists = import_node_fs2.existsSync) {
 }
 
 // src/version.ts
-var RIGKIT_PROVIDER_VSCODE_VERSION = "0.2.1";
+var RIGKIT_PROVIDER_VSCODE_VERSION = "0.2.3";
 
 // src/extension.ts
 var VSCODE_HOST_METHODS = [
@@ -31022,11 +31134,6 @@ class RigkitVsCodeHost {
     const selected = operation ?? await pickOperation(operations);
     if (!selected)
       return;
-    const unsupported = unsupportedRequirements(selected);
-    if (unsupported) {
-      await vscode.window.showErrorMessage(unsupported);
-      return;
-    }
     const workspaces = await this.listWorkspaces();
     const input = await collectOperationInput(selected, workspaces, operationPrompt(presetWorkspace));
     if (!input)
@@ -31148,7 +31255,7 @@ class WorkspacesProvider {
   getTreeItem(workspace2) {
     const item = new vscode.TreeItem(workspace2.name, vscode.TreeItemCollapsibleState.None);
     item.description = workspace2.workflow;
-    item.tooltip = workspace2.resourceId || workspace2.name;
+    item.tooltip = workspace2.name;
     item.iconPath = new vscode.ThemeIcon("server");
     item.contextValue = "rigkitWorkspace";
     item.command = {
@@ -31212,7 +31319,7 @@ async function pickWorkspace(title, workspaces) {
   const items = workspaces.map((workspace2) => ({
     label: workspace2.name,
     description: workspace2.workflow,
-    detail: workspace2.resourceId,
+    detail: workspace2.createdAt,
     workspace: workspace2
   }));
   const picked = await vscode.window.showQuickPick(items, { title, ignoreFocusOut: true });
@@ -31301,17 +31408,6 @@ async function openExternal(params2) {
   await vscode.env.openExternal(vscode.Uri.parse(target));
   return null;
 }
-function unsupportedRequirements(operation) {
-  const unsupportedCapability = operation.requiredHostCapabilities?.[0];
-  if (unsupportedCapability) {
-    return `Operation "${operation.id}" requires host capability "${unsupportedCapability.id}". VS Code does not support that capability.`;
-  }
-  const unsupportedMethod = operation.requiredHostMethods?.find((method) => !VSCODE_HOST_METHODS.some((supported) => supported.id === method.id && (!method.modes?.length || method.modes.every((mode) => supported.modes?.includes(mode)))));
-  if (unsupportedMethod) {
-    return `Operation "${operation.id}" requires host method "${unsupportedMethod.id}".`;
-  }
-  return;
-}
 function isHostRequestMessage(value3) {
   return isRecord3(value3) && value3.type === "host.request" && typeof value3.id === "string" && typeof value3.method === "string";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigkit/provider-vscode",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "repository": {
     "type": "git",
@@ -57,7 +57,7 @@
     "README.md"
   ],
   "dependencies": {
-    "@rigkit/runtime-client": "0.2.1"
+    "@rigkit/runtime-client": "0.2.3"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/extension.ts

@@ -82,12 +82,6 @@ class RigkitVsCodeHost {
     const selected = operation ?? await pickOperation(operations);
     if (!selected) return;
 
-    const unsupported = unsupportedRequirements(selected);
-    if (unsupported) {
-      await vscode.window.showErrorMessage(unsupported);
-      return;
-    }
-
     const workspaces = await this.listWorkspaces();
     const input = await collectOperationInput(selected, workspaces, operationPrompt(presetWorkspace));
     if (!input) return;
@@ -213,7 +207,7 @@ class WorkspacesProvider implements vscode.TreeDataProvider<RuntimeControlWorksp
   getTreeItem(workspace: RuntimeControlWorkspace): vscode.TreeItem {
     const item = new vscode.TreeItem(workspace.name, vscode.TreeItemCollapsibleState.None);
     item.description = workspace.workflow;
-    item.tooltip = workspace.resourceId || workspace.name;
+    item.tooltip = workspace.name;
     item.iconPath = new vscode.ThemeIcon("server");
     item.contextValue = "rigkitWorkspace";
     item.command = {
@@ -286,7 +280,7 @@ async function pickWorkspace(
   const items = workspaces.map((workspace) => ({
     label: workspace.name,
     description: workspace.workflow,
-    detail: workspace.resourceId,
+    detail: workspace.createdAt,
     workspace,
   }));
   const picked = await vscode.window.showQuickPick(items, { title, ignoreFocusOut: true });
@@ -381,22 +375,6 @@ async function openExternal(params: unknown): Promise<null> {
   return null;
 }
 
-function unsupportedRequirements(operation: RuntimeControlOperation): string | undefined {
-  const unsupportedCapability = operation.requiredHostCapabilities?.[0];
-  if (unsupportedCapability) {
-    return `Operation "${operation.id}" requires host capability "${unsupportedCapability.id}". VS Code does not support that capability.`;
-  }
-  const unsupportedMethod = operation.requiredHostMethods?.find((method) =>
-    !VSCODE_HOST_METHODS.some((supported) =>
-      supported.id === method.id && (!method.modes?.length || method.modes.every((mode) => supported.modes?.includes(mode)))
-    )
-  );
-  if (unsupportedMethod) {
-    return `Operation "${operation.id}" requires host method "${unsupportedMethod.id}".`;
-  }
-  return undefined;
-}
-
 function isHostRequestMessage(value: unknown): value is HostRequestMessage {
   return isRecord(value) &&
     value.type === "host.request" &&

package/src/input.test.ts

@@ -71,13 +71,8 @@ function workspaceRecord(name: string): RuntimeControlWorkspace {
   return {
     id: `ws-${name}`,
     name,
-    providerId: "test",
     workflow: "test",
-    resourceId: `resource-${name}`,
-    sourceRef: null,
-    context: {},
-    metadata: {},
-    data: {},
+    ctx: {},
     createdAt: "2026-05-10T00:00:00.000Z",
     updatedAt: "2026-05-10T00:00:00.000Z",
   };

package/src/version.ts

@@ -1 +1 @@
-export const RIGKIT_PROVIDER_VSCODE_VERSION = "0.2.1";
+export const RIGKIT_PROVIDER_VSCODE_VERSION = "0.2.3";