@dexto/image-local 1.7.1 → 1.8.0

package/README.md

@@ -7,7 +7,9 @@ This package default-exports a typed `DextoImage` (no side effects, no registrie
 
 ## What’s included
 
-- **Storage factories**: local filesystem blob store, SQLite database, in-memory cache (plus in-memory alternatives; Postgres/Redis factories are included but require optional deps)
+- **Stores**: local `DextoStores` built with filesystem artifacts, SQLite session data, and in-memory fast state by default
+- **Workspace handles**: local filesystem workspace handles for local CLI/app runs
+- **Skill sources**: local and plugin skill directories loaded through `SkillManager`
 - **Tool factories**: builtin, filesystem, process, todo, plan, agent-spawner
 - **Hooks**: content-policy, response-sanitizer
 - **Compaction**: reactive-overflow, noop
@@ -44,7 +46,7 @@ tools:
 
 Notes:
 - Omit `tools:` to use `image.defaults.tools`.
-- Storage defaults come from `image.defaults.storage` (override with `storage:` in YAML).
+- Store defaults come from `image.defaults.storage` and are resolved by `storage.createStores(...)`.
 - `filesystem-tools.allowedPaths` defines the static sandbox. In manual mode, attempts to access paths outside the sandbox trigger a directory access approval prompt; if approved, access is granted for the current session or for a single occurrence.
 
 ## App usage (direct import)

package/dist/index.cjs

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+  LocalWorkspaceHandleProvider: () => import_local_workspace_handle_provider.LocalWorkspaceHandleProvider,
   default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
@@ -46,6 +47,7 @@ var import_tools_plan = require("@dexto/tools-plan");
 var import_tools_scheduler = require("@dexto/tools-scheduler");
 var import_tools_lifecycle = require("@dexto/tools-lifecycle");
 var import_agent_management = require("@dexto/agent-management");
+var import_local_workspace_handle_provider = require("./local-workspace-handle-provider.js");
 const import_meta = {};
 function readPackageJson(packageJsonPath) {
   if (!(0, import_node_fs.existsSync)(packageJsonPath)) {
@@ -136,6 +138,82 @@ const reactiveOverflowCompactionFactory = {
     }
   })
 };
+async function createLocalStores(config, logger) {
+  let blobStore;
+  if (config.blob.type === "local") {
+    blobStore = new import_storage.LocalBlobStore(import_storage.LocalBlobStoreSchema.parse(config.blob), logger);
+  } else {
+    const memoryBlobConfig = import_storage.InMemoryBlobStoreSchema.parse(config.blob);
+    blobStore = new import_storage.MemoryBlobStore(
+      {
+        maxBlobSize: memoryBlobConfig.maxBlobSize,
+        maxTotalSize: memoryBlobConfig.maxTotalSize
+      },
+      logger
+    );
+  }
+  let database;
+  if (config.database.type === "sqlite") {
+    database = new import_storage.SQLiteStore(import_storage.SqliteDatabaseSchema.parse(config.database), logger);
+  } else if (config.database.type === "postgres") {
+    database = new import_storage.PostgresStore(import_storage.PostgresDatabaseSchema.parse(config.database), logger);
+  } else {
+    import_storage.InMemoryDatabaseSchema.parse(config.database);
+    database = new import_storage.MemoryDatabaseStore();
+  }
+  let cache;
+  if (config.cache.type === "redis") {
+    cache = new import_storage.RedisStore(import_storage.RedisCacheSchema.parse(config.cache), logger);
+  } else {
+    import_storage.InMemoryCacheSchema.parse(config.cache);
+    cache = new import_storage.MemoryCacheStore();
+  }
+  return new import_core.BackendDextoStores(
+    {
+      conversation: new import_core.DatabaseConversationStore(database, logger),
+      sessions: new import_core.DatabaseBackedSessionStore(database, cache),
+      memories: new import_core.DatabaseBackedMemoryStore(database),
+      workspaces: new import_core.DatabaseBackedWorkspaceStore(database),
+      approvals: new import_core.DatabaseBackedApprovalStore(database, cache, logger),
+      toolPreferences: new import_core.DatabaseBackedToolPreferenceStore(database, cache, logger),
+      toolState: new import_core.DatabaseBackedToolStateStore(database),
+      steerQueue: new import_core.DatabaseBackedSessionMessageQueueStore(
+        database,
+        cache,
+        logger,
+        import_core.SESSION_STEER_QUEUE_KEY_PREFIX
+      ),
+      followUpQueue: new import_core.DatabaseBackedSessionMessageQueueStore(
+        database,
+        cache,
+        logger,
+        import_core.SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX
+      ),
+      customPrompts: new import_core.DatabaseBackedCustomPromptStore(database),
+      artifacts: new import_core.DatabaseBackedArtifactStore(blobStore),
+      runtimeEvents: new import_core.DatabaseBackedRuntimeEventStore(database),
+      toolExecutions: new import_core.DatabaseBackedToolExecutionStore(database)
+    },
+    {
+      async connect() {
+        await cache.connect();
+        await database.connect();
+        await blobStore.connect();
+      },
+      async disconnect() {
+        await Promise.all([
+          cache.disconnect(),
+          database.disconnect(),
+          blobStore.disconnect()
+        ]);
+      },
+      isConnected() {
+        return cache.isConnected() && database.isConnected() && blobStore.isConnected();
+      }
+    },
+    "backend"
+  );
+}
 const imageLocal = {
   metadata: {
     name: imageMetadata.name,
@@ -168,7 +246,6 @@ const imageLocal = {
         title: "Plan Mode",
         description: "Internal prompt used by the CLI plan mode toggle. This is injected into the first user message when plan mode is enabled.",
         "user-invocable": false,
-        "disable-model-invocation": true,
         prompt: [
           "You are in PLAN MODE.",
           "",
@@ -202,19 +279,8 @@ const imageLocal = {
     "agent-spawner": import_agent_management.agentSpawnerToolsFactory
   },
   storage: {
-    blob: {
-      local: import_storage.localBlobStoreFactory,
-      "in-memory": import_storage.inMemoryBlobStoreFactory
-    },
-    database: {
-      sqlite: import_storage.sqliteDatabaseFactory,
-      postgres: import_storage.postgresDatabaseFactory,
-      "in-memory": import_storage.inMemoryDatabaseFactory
-    },
-    cache: {
-      "in-memory": import_storage.inMemoryCacheFactory,
-      redis: import_storage.redisCacheFactory
-    }
+    configSchema: import_storage.StorageSchema,
+    createStores: createLocalStores
   },
   hooks: {
     "content-policy": contentPolicyFactory,
@@ -224,6 +290,18 @@ const imageLocal = {
     "reactive-overflow": reactiveOverflowCompactionFactory,
     noop: noopCompactionFactory
   },
-  logger: import_core.defaultLoggerFactory
+  logger: import_core.defaultLoggerFactory,
+  workspace: {
+    create: () => new import_local_workspace_handle_provider.LocalWorkspaceHandleProvider()
+  },
+  skills: {
+    create: (context) => (0, import_agent_management.createLocalSkillSources)({
+      workspaceRoot: context?.hostContext?.workspaceRoot
+    })
+  }
 };
 var index_default = imageLocal;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalWorkspaceHandleProvider
+});

package/dist/index.d.cts

@@ -1,5 +1,13 @@
 import { DextoImage } from '@dexto/agent-config';
+import { WorkspaceHandleProvider, WorkspaceContext, OpenWorkspaceInput, WorkspaceHandle } from '@dexto/core/workspace';
+
+declare class LocalWorkspaceHandleProvider implements WorkspaceHandleProvider {
+    open(input: {
+        context: WorkspaceContext;
+        input?: OpenWorkspaceInput;
+    }): Promise<WorkspaceHandle>;
+}
 
 declare const imageLocal: DextoImage;
 
-export { imageLocal as default };
+export { LocalWorkspaceHandleProvider, imageLocal as default };

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { type DextoImage } from '@dexto/agent-config';
+import { LocalWorkspaceHandleProvider } from './local-workspace-handle-provider.js';
 declare const imageLocal: DextoImage;
 export default imageLocal;
+export { LocalWorkspaceHandleProvider };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,UAAU,EAOlB,MAAM,qBAAqB,CAAC;AAmJ7B,QAAA,MAAM,UAAU,EAAE,UA0FjB,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,KAAK,UAAU,EAOlB,MAAM,qBAAqB,CAAC;AA2D7B,OAAO,EAAE,4BAA4B,EAAE,MAAM,sCAAsC,CAAC;AAmMpF,QAAA,MAAM,UAAU,EAAE,UAuFjB,CAAC;AAEF,eAAe,UAAU,CAAC;AAC1B,OAAO,EAAE,4BAA4B,EAAE,CAAC"}

package/dist/index.js

@@ -8,19 +8,42 @@ import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import {
   ContentPolicyHook,
+  BackendDextoStores,
+  DatabaseBackedApprovalStore,
+  DatabaseBackedArtifactStore,
+  DatabaseBackedCustomPromptStore,
+  DatabaseBackedMemoryStore,
+  DatabaseBackedRuntimeEventStore,
+  DatabaseBackedSessionMessageQueueStore,
+  DatabaseBackedSessionStore,
+  DatabaseBackedToolExecutionStore,
+  DatabaseBackedToolPreferenceStore,
+  DatabaseBackedToolStateStore,
+  DatabaseBackedWorkspaceStore,
+  SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX,
+  SESSION_STEER_QUEUE_KEY_PREFIX,
+  DatabaseConversationStore,
   ResponseSanitizerHook,
   defaultLoggerFactory,
   NoOpCompactionStrategy,
   ReactiveOverflowCompactionStrategy
 } from "@dexto/core";
 import {
-  localBlobStoreFactory,
-  inMemoryBlobStoreFactory,
-  sqliteDatabaseFactory,
-  postgresDatabaseFactory,
-  inMemoryDatabaseFactory,
-  inMemoryCacheFactory,
-  redisCacheFactory
+  StorageSchema,
+  LocalBlobStoreSchema,
+  InMemoryBlobStoreSchema,
+  SqliteDatabaseSchema,
+  PostgresDatabaseSchema,
+  InMemoryDatabaseSchema,
+  RedisCacheSchema,
+  InMemoryCacheSchema,
+  LocalBlobStore,
+  MemoryBlobStore,
+  SQLiteStore,
+  PostgresStore,
+  MemoryDatabaseStore,
+  RedisStore,
+  MemoryCacheStore
 } from "@dexto/storage";
 import { builtinToolsFactory } from "@dexto/tools-builtins";
 import { fileSystemToolsFactory } from "@dexto/tools-filesystem";
@@ -31,9 +54,11 @@ import { schedulerToolsFactory } from "@dexto/tools-scheduler";
 import { lifecycleToolsFactory } from "@dexto/tools-lifecycle";
 import {
   agentSpawnerToolsFactory,
+  createLocalSkillSources,
   creatorToolsFactory,
   getDextoPackageRoot
 } from "@dexto/agent-management";
+import { LocalWorkspaceHandleProvider } from "./local-workspace-handle-provider.js";
 function readPackageJson(packageJsonPath) {
   if (!existsSync(packageJsonPath)) {
     return null;
@@ -123,6 +148,82 @@ const reactiveOverflowCompactionFactory = {
     }
   })
 };
+async function createLocalStores(config, logger) {
+  let blobStore;
+  if (config.blob.type === "local") {
+    blobStore = new LocalBlobStore(LocalBlobStoreSchema.parse(config.blob), logger);
+  } else {
+    const memoryBlobConfig = InMemoryBlobStoreSchema.parse(config.blob);
+    blobStore = new MemoryBlobStore(
+      {
+        maxBlobSize: memoryBlobConfig.maxBlobSize,
+        maxTotalSize: memoryBlobConfig.maxTotalSize
+      },
+      logger
+    );
+  }
+  let database;
+  if (config.database.type === "sqlite") {
+    database = new SQLiteStore(SqliteDatabaseSchema.parse(config.database), logger);
+  } else if (config.database.type === "postgres") {
+    database = new PostgresStore(PostgresDatabaseSchema.parse(config.database), logger);
+  } else {
+    InMemoryDatabaseSchema.parse(config.database);
+    database = new MemoryDatabaseStore();
+  }
+  let cache;
+  if (config.cache.type === "redis") {
+    cache = new RedisStore(RedisCacheSchema.parse(config.cache), logger);
+  } else {
+    InMemoryCacheSchema.parse(config.cache);
+    cache = new MemoryCacheStore();
+  }
+  return new BackendDextoStores(
+    {
+      conversation: new DatabaseConversationStore(database, logger),
+      sessions: new DatabaseBackedSessionStore(database, cache),
+      memories: new DatabaseBackedMemoryStore(database),
+      workspaces: new DatabaseBackedWorkspaceStore(database),
+      approvals: new DatabaseBackedApprovalStore(database, cache, logger),
+      toolPreferences: new DatabaseBackedToolPreferenceStore(database, cache, logger),
+      toolState: new DatabaseBackedToolStateStore(database),
+      steerQueue: new DatabaseBackedSessionMessageQueueStore(
+        database,
+        cache,
+        logger,
+        SESSION_STEER_QUEUE_KEY_PREFIX
+      ),
+      followUpQueue: new DatabaseBackedSessionMessageQueueStore(
+        database,
+        cache,
+        logger,
+        SESSION_FOLLOW_UP_QUEUE_KEY_PREFIX
+      ),
+      customPrompts: new DatabaseBackedCustomPromptStore(database),
+      artifacts: new DatabaseBackedArtifactStore(blobStore),
+      runtimeEvents: new DatabaseBackedRuntimeEventStore(database),
+      toolExecutions: new DatabaseBackedToolExecutionStore(database)
+    },
+    {
+      async connect() {
+        await cache.connect();
+        await database.connect();
+        await blobStore.connect();
+      },
+      async disconnect() {
+        await Promise.all([
+          cache.disconnect(),
+          database.disconnect(),
+          blobStore.disconnect()
+        ]);
+      },
+      isConnected() {
+        return cache.isConnected() && database.isConnected() && blobStore.isConnected();
+      }
+    },
+    "backend"
+  );
+}
 const imageLocal = {
   metadata: {
     name: imageMetadata.name,
@@ -155,7 +256,6 @@ const imageLocal = {
         title: "Plan Mode",
         description: "Internal prompt used by the CLI plan mode toggle. This is injected into the first user message when plan mode is enabled.",
         "user-invocable": false,
-        "disable-model-invocation": true,
         prompt: [
           "You are in PLAN MODE.",
           "",
@@ -189,19 +289,8 @@ const imageLocal = {
     "agent-spawner": agentSpawnerToolsFactory
   },
   storage: {
-    blob: {
-      local: localBlobStoreFactory,
-      "in-memory": inMemoryBlobStoreFactory
-    },
-    database: {
-      sqlite: sqliteDatabaseFactory,
-      postgres: postgresDatabaseFactory,
-      "in-memory": inMemoryDatabaseFactory
-    },
-    cache: {
-      "in-memory": inMemoryCacheFactory,
-      redis: redisCacheFactory
-    }
+    configSchema: StorageSchema,
+    createStores: createLocalStores
   },
   hooks: {
     "content-policy": contentPolicyFactory,
@@ -211,9 +300,18 @@ const imageLocal = {
     "reactive-overflow": reactiveOverflowCompactionFactory,
     noop: noopCompactionFactory
   },
-  logger: defaultLoggerFactory
+  logger: defaultLoggerFactory,
+  workspace: {
+    create: () => new LocalWorkspaceHandleProvider()
+  },
+  skills: {
+    create: (context) => createLocalSkillSources({
+      workspaceRoot: context?.hostContext?.workspaceRoot
+    })
+  }
 };
 var index_default = imageLocal;
 export {
+  LocalWorkspaceHandleProvider,
   index_default as default
 };

package/dist/local-workspace-handle-provider.cjs

@@ -0,0 +1,151 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var local_workspace_handle_provider_exports = {};
+__export(local_workspace_handle_provider_exports, {
+  LocalWorkspaceHandleProvider: () => LocalWorkspaceHandleProvider
+});
+module.exports = __toCommonJS(local_workspace_handle_provider_exports);
+var import_node_child_process = require("node:child_process");
+var import_promises = require("node:fs/promises");
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_util = require("node:util");
+var import_glob = require("glob");
+var import_workspace = require("@dexto/core/workspace");
+const exec = (0, import_node_util.promisify)(import_node_child_process.exec);
+class LocalWorkspaceHandleProvider {
+  async open(input) {
+    const root = import_node_path.default.resolve(input.context.path);
+    const files = new LocalWorkspaceFiles(root);
+    const capabilities = resolveCapabilities(input.input);
+    const handle = {
+      context: {
+        ...input.context,
+        path: root
+      },
+      capabilities,
+      files
+    };
+    if (capabilities.includes("processes")) {
+      handle.processes = new LocalWorkspaceProcesses(root);
+    }
+    return handle;
+  }
+}
+class LocalWorkspaceFiles {
+  constructor(root) {
+    this.root = root;
+  }
+  readText = async (filePath) => {
+    try {
+      return await (0, import_promises.readFile)(this.resolveInsideRoot(filePath), "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw import_workspace.WorkspaceError.fileNotFound(filePath);
+      }
+      throw error;
+    }
+  };
+  readFile = async (filePath) => {
+    return this.readText(filePath);
+  };
+  glob = async (pattern) => {
+    this.assertRelativePattern(pattern);
+    const files = await (0, import_glob.glob)(pattern, {
+      cwd: this.root,
+      absolute: false,
+      nodir: true,
+      follow: false,
+      posix: true
+    });
+    return files.sort();
+  };
+  writeFile = async (filePath, content) => {
+    const resolvedPath = this.resolveInsideRoot(filePath);
+    await (0, import_promises.mkdir)(import_node_path.default.dirname(resolvedPath), { recursive: true });
+    try {
+      await (0, import_promises.writeFile)(resolvedPath, content, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw import_workspace.WorkspaceError.fileNotFound(filePath);
+      }
+      throw error;
+    }
+  };
+  listFiles = async (directoryPath = ".") => {
+    const resolvedPath = this.resolveInsideRoot(directoryPath);
+    const relativePath = import_node_path.default.relative(this.root, resolvedPath);
+    const pattern = relativePath ? `${relativePath.split(import_node_path.default.sep).join("/")}/**/*` : "**/*";
+    return this.glob(pattern);
+  };
+  resolveInsideRoot(filePath) {
+    const resolvedPath = import_node_path.default.isAbsolute(filePath) ? import_node_path.default.resolve(filePath) : import_node_path.default.resolve(this.root, filePath);
+    const relativePath = import_node_path.default.relative(this.root, resolvedPath);
+    if (relativePath === "" || !relativePath.startsWith("..") && !import_node_path.default.isAbsolute(relativePath)) {
+      return resolvedPath;
+    }
+    throw import_workspace.WorkspaceError.pathOutsideWorkspace(filePath);
+  }
+  assertRelativePattern(pattern) {
+    if (import_node_path.default.isAbsolute(pattern) || pattern.split(/[\\/]/).includes("..")) {
+      throw import_workspace.WorkspaceError.pathOutsideWorkspace(pattern);
+    }
+  }
+}
+class LocalWorkspaceProcesses {
+  constructor(root) {
+    this.root = root;
+  }
+  exec = async (input) => {
+    const cwd = input.cwd === void 0 ? this.root : resolveInsideRoot(this.root, input.cwd);
+    const result = await exec(input.command, { cwd });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  };
+}
+function resolveCapabilities(input) {
+  const capabilities = ["files"];
+  if (input?.intent === "process" || input?.capabilities?.includes("processes")) {
+    capabilities.push("processes");
+  }
+  return capabilities;
+}
+function resolveInsideRoot(root, filePath) {
+  const resolvedPath = import_node_path.default.isAbsolute(filePath) ? import_node_path.default.resolve(filePath) : import_node_path.default.resolve(root, filePath);
+  const relativePath = import_node_path.default.relative(root, resolvedPath);
+  if (relativePath === "" || !relativePath.startsWith("..") && !import_node_path.default.isAbsolute(relativePath)) {
+    return resolvedPath;
+  }
+  throw import_workspace.WorkspaceError.pathOutsideWorkspace(filePath);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LocalWorkspaceHandleProvider
+});

package/dist/local-workspace-handle-provider.d.ts

@@ -0,0 +1,8 @@
+import type { OpenWorkspaceInput, WorkspaceContext, WorkspaceHandle, WorkspaceHandleProvider } from '@dexto/core/workspace';
+export declare class LocalWorkspaceHandleProvider implements WorkspaceHandleProvider {
+    open(input: {
+        context: WorkspaceContext;
+        input?: OpenWorkspaceInput;
+    }): Promise<WorkspaceHandle>;
+}
+//# sourceMappingURL=local-workspace-handle-provider.d.ts.map

package/dist/local-workspace-handle-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-workspace-handle-provider.d.ts","sourceRoot":"","sources":["../src/local-workspace-handle-provider.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EACR,kBAAkB,EAElB,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EAC1B,MAAM,uBAAuB,CAAC;AAI/B,qBAAa,4BAA6B,YAAW,uBAAuB;IAClE,IAAI,CAAC,KAAK,EAAE;QACd,OAAO,EAAE,gBAAgB,CAAC;QAC1B,KAAK,CAAC,EAAE,kBAAkB,CAAC;KAC9B,GAAG,OAAO,CAAC,eAAe,CAAC;CAoB/B"}

package/dist/local-workspace-handle-provider.js

@@ -0,0 +1,117 @@
+import { exec as execCallback } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { glob } from "glob";
+import { WorkspaceError } from "@dexto/core/workspace";
+const exec = promisify(execCallback);
+class LocalWorkspaceHandleProvider {
+  async open(input) {
+    const root = path.resolve(input.context.path);
+    const files = new LocalWorkspaceFiles(root);
+    const capabilities = resolveCapabilities(input.input);
+    const handle = {
+      context: {
+        ...input.context,
+        path: root
+      },
+      capabilities,
+      files
+    };
+    if (capabilities.includes("processes")) {
+      handle.processes = new LocalWorkspaceProcesses(root);
+    }
+    return handle;
+  }
+}
+class LocalWorkspaceFiles {
+  constructor(root) {
+    this.root = root;
+  }
+  readText = async (filePath) => {
+    try {
+      return await readFile(this.resolveInsideRoot(filePath), "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw WorkspaceError.fileNotFound(filePath);
+      }
+      throw error;
+    }
+  };
+  readFile = async (filePath) => {
+    return this.readText(filePath);
+  };
+  glob = async (pattern) => {
+    this.assertRelativePattern(pattern);
+    const files = await glob(pattern, {
+      cwd: this.root,
+      absolute: false,
+      nodir: true,
+      follow: false,
+      posix: true
+    });
+    return files.sort();
+  };
+  writeFile = async (filePath, content) => {
+    const resolvedPath = this.resolveInsideRoot(filePath);
+    await mkdir(path.dirname(resolvedPath), { recursive: true });
+    try {
+      await writeFile(resolvedPath, content, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw WorkspaceError.fileNotFound(filePath);
+      }
+      throw error;
+    }
+  };
+  listFiles = async (directoryPath = ".") => {
+    const resolvedPath = this.resolveInsideRoot(directoryPath);
+    const relativePath = path.relative(this.root, resolvedPath);
+    const pattern = relativePath ? `${relativePath.split(path.sep).join("/")}/**/*` : "**/*";
+    return this.glob(pattern);
+  };
+  resolveInsideRoot(filePath) {
+    const resolvedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(this.root, filePath);
+    const relativePath = path.relative(this.root, resolvedPath);
+    if (relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+      return resolvedPath;
+    }
+    throw WorkspaceError.pathOutsideWorkspace(filePath);
+  }
+  assertRelativePattern(pattern) {
+    if (path.isAbsolute(pattern) || pattern.split(/[\\/]/).includes("..")) {
+      throw WorkspaceError.pathOutsideWorkspace(pattern);
+    }
+  }
+}
+class LocalWorkspaceProcesses {
+  constructor(root) {
+    this.root = root;
+  }
+  exec = async (input) => {
+    const cwd = input.cwd === void 0 ? this.root : resolveInsideRoot(this.root, input.cwd);
+    const result = await exec(input.command, { cwd });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  };
+}
+function resolveCapabilities(input) {
+  const capabilities = ["files"];
+  if (input?.intent === "process" || input?.capabilities?.includes("processes")) {
+    capabilities.push("processes");
+  }
+  return capabilities;
+}
+function resolveInsideRoot(root, filePath) {
+  const resolvedPath = path.isAbsolute(filePath) ? path.resolve(filePath) : path.resolve(root, filePath);
+  const relativePath = path.relative(root, resolvedPath);
+  if (relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath)) {
+    return resolvedPath;
+  }
+  throw WorkspaceError.pathOutsideWorkspace(filePath);
+}
+export {
+  LocalWorkspaceHandleProvider
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/image-local",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Local development base image for Dexto agents with filesystem and process tools",
   "type": "module",
   "main": "./dist/index.js",
@@ -20,18 +20,19 @@
     "process"
   ],
   "dependencies": {
+    "glob": "^12.0.0",
     "zod": "^4.3.6",
-    "@dexto/agent-config": "1.7.1",
-    "@dexto/agent-management": "1.7.1",
-    "@dexto/core": "1.7.1",
-    "@dexto/storage": "1.7.1",
-    "@dexto/tools-builtins": "1.7.1",
-    "@dexto/tools-filesystem": "1.7.1",
-    "@dexto/tools-lifecycle": "1.7.1",
-    "@dexto/tools-plan": "1.7.1",
-    "@dexto/tools-process": "1.7.1",
-    "@dexto/tools-scheduler": "1.7.1",
-    "@dexto/tools-todo": "1.7.1"
+    "@dexto/agent-config": "1.8.0",
+    "@dexto/agent-management": "1.8.0",
+    "@dexto/core": "1.8.0",
+    "@dexto/storage": "1.8.0",
+    "@dexto/tools-builtins": "1.8.0",
+    "@dexto/tools-filesystem": "1.8.0",
+    "@dexto/tools-lifecycle": "1.8.0",
+    "@dexto/tools-plan": "1.8.0",
+    "@dexto/tools-process": "1.8.0",
+    "@dexto/tools-scheduler": "1.8.0",
+    "@dexto/tools-todo": "1.8.0"
   },
   "devDependencies": {
     "tsup": "^8.0.0",