@blogic-cz/agent-tools 0.14.10 → 0.14.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blogic-cz/agent-tools",
-  "version": "0.14.10",
+  "version": "0.14.12",
   "description": "CLI tools for AI coding agent workflows — GitHub, database, Kubernetes, Azure DevOps, logs, sessions, and audit",
   "keywords": [
     "agent",

package/src/db-tool/schema.ts

@@ -5,18 +5,39 @@
  * This is a known limitation — callers must validate the table name
  * via `isValidTableName()` before calling `getColumns()`.
  */
+export const SYSTEM_SCHEMAS_SQL = "'pg_catalog', 'information_schema'";
+
+export function parseTableReference(tableName: string): { schemaName?: string; tableName: string } {
+  const [schemaName, name, ...extra] = tableName.split(".");
+
+  if (name && extra.length === 0) {
+    return { schemaName, tableName: name };
+  }
+
+  return { tableName };
+}
+
 export const SCHEMA_QUERIES = {
   tables: `
-    SELECT tablename as name
+    SELECT
+      schemaname as schema,
+      tablename as name,
+      schemaname || '.' || tablename as qualified_name
     FROM pg_tables
-    WHERE schemaname = 'public'
-    ORDER BY tablename
+    WHERE schemaname NOT IN (${SYSTEM_SCHEMAS_SQL})
+    ORDER BY schemaname, tablename
   `,
   columns: (tableName: string) => {
-    const escapedTableName = tableName.replaceAll("'", "''");
+    const tableReference = parseTableReference(tableName);
+    const escapedTableName = tableReference.tableName.replaceAll("'", "''");
+    const schemaFilter = tableReference.schemaName
+      ? `AND c.table_schema = '${tableReference.schemaName.replaceAll("'", "''")}'`
+      : `AND c.table_schema NOT IN (${SYSTEM_SCHEMAS_SQL})`;
 
     return `
     SELECT
+      c.table_schema as schema,
+      c.table_name as table,
       c.column_name as name,
       c.data_type as type,
       c.is_nullable = 'YES' as nullable,
@@ -32,14 +53,16 @@ export const SCHEMA_QUERIES = {
       ) as is_primary_key
     FROM information_schema.columns c
     WHERE c.table_name = '${escapedTableName}'
-    AND c.table_schema = 'public'
-    ORDER BY c.ordinal_position
+    ${schemaFilter}
+    ORDER BY c.table_schema, c.ordinal_position
   `;
   },
   relationships: `
     SELECT
+      tc.table_schema as from_schema,
       tc.table_name as from_table,
       kcu.column_name as from_column,
+      ccu.table_schema as to_schema,
       ccu.table_name as to_table,
       ccu.column_name as to_column,
       tc.constraint_name
@@ -49,10 +72,10 @@ export const SCHEMA_QUERIES = {
       AND tc.table_schema = kcu.table_schema
     JOIN information_schema.constraint_column_usage ccu
       ON ccu.constraint_name = tc.constraint_name
-      AND ccu.table_schema = tc.table_schema
+      AND ccu.constraint_schema = tc.constraint_schema
     WHERE tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_schema = 'public'
-    ORDER BY tc.table_name, kcu.column_name
+    AND tc.table_schema NOT IN (${SYSTEM_SCHEMAS_SQL})
+    ORDER BY tc.table_schema, tc.table_name, kcu.column_name
   `,
 };
 

package/src/db-tool/security.ts

@@ -10,7 +10,7 @@ const MUTATION_PATTERNS = [
   /^\s*CREATE\s+/i,
 ];
 
-const TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const TABLE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$/;
 
 /**
  * Strip SQL comments (block and line) while preserving string literals.

package/src/db-tool/service.ts

@@ -15,7 +15,13 @@ import {
   DbTunnelError,
   type DbError,
 } from "./errors";
-import { getColumns, getRelationships, getTableNames } from "./schema";
+import {
+  getColumns,
+  getRelationships,
+  getTableNames,
+  parseTableReference,
+  SYSTEM_SCHEMAS_SQL,
+} from "./schema";
 import { detectSchemaError, isValidTableName, isMutationQuery } from "./security";
 import { transformQueryResult } from "./transformers";
 
@@ -324,7 +330,7 @@ export class DbService extends Context.Service<
         ) {
           const command = buildPsqlCommand(
             config,
-            "SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename;",
+            `SELECT schemaname || '.' || tablename FROM pg_tables WHERE schemaname NOT IN (${SYSTEM_SCHEMAS_SQL}) ORDER BY schemaname, tablename;`,
             password,
             true,
           );
@@ -356,11 +362,16 @@ export class DbService extends Context.Service<
             return [] as string[];
           }
 
-          const escapedTableName = tableName.replaceAll("'", "''");
+          const tableReference = parseTableReference(tableName);
+          const escapedSchemaName = tableReference.schemaName?.replaceAll("'", "''");
+          const escapedTableName = tableReference.tableName.replaceAll("'", "''");
+          const schemaFilter = escapedSchemaName
+            ? `AND table_schema = '${escapedSchemaName}'`
+            : `AND table_schema NOT IN (${SYSTEM_SCHEMAS_SQL})`;
 
           const command = buildPsqlCommand(
             config,
-            `SELECT column_name FROM information_schema.columns WHERE table_name = '${escapedTableName}' AND table_schema = 'public' ORDER BY ordinal_position;`,
+            `SELECT column_name FROM information_schema.columns WHERE table_name = '${escapedTableName}' ${schemaFilter} ORDER BY table_schema, ordinal_position;`,
             password,
             true,
           );
@@ -516,21 +527,25 @@ export class DbService extends Context.Service<
           }
 
           const tables = tablesResult.data as {
+            schema?: string;
             name: string;
+            qualified_name?: string;
           }[];
           const fullSchema: Record<string, unknown>[] = [];
 
           for (const table of tables) {
             const columnsResult = yield* executeSelectQuery(
               config,
-              getColumns(table.name),
+              getColumns(table.qualified_name ?? table.name),
               password,
               startTimeMs,
             ).pipe(Effect.catch(() => Effect.succeed(null)));
 
             if (columnsResult && columnsResult.success && columnsResult.data) {
               fullSchema.push({
+                schema: table.schema,
                 table: table.name,
+                qualified_name: table.qualified_name ?? table.name,
                 columns: columnsResult.data,
               });
             }
@@ -668,7 +683,7 @@ export class DbService extends Context.Service<
               return {
                 success: false,
                 error:
-                  "Invalid table name. Use only letters, numbers, and underscores, and start with a letter or underscore.",
+                  "Invalid table name. Use only letters, numbers, underscores, and an optional schema prefix, and start each identifier with a letter or underscore.",
                 executionTimeMs: Number(endTime) - Number(startTimeMs),
               };
             }

package/src/observability-tool/logs.ts

@@ -12,28 +12,25 @@ import {
   resolveConfig,
 } from "./shared";
 
-type LogLine = {
-  readonly timestamp: string;
-  readonly line: string;
-  readonly body?: string;
-  readonly severity?: string;
-  readonly attributes?: Record<string, unknown>;
-  readonly labels: Record<string, string>;
-};
-
-type StructuredLogLine = {
-  readonly body?: string;
-  readonly severity?: string;
-  readonly attributes?: Record<string, unknown>;
-};
+import type { LogLine, StructuredLogLine } from "./types";
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.values(value).every((item) => typeof item === "string")
+  );
+}
 
 function parseLabel(value: string | Record<string, string>): Record<string, string> {
-  if (typeof value === "object" && value !== null) {
+  if (isStringRecord(value)) {
     return value;
   }
 
   try {
-    return JSON.parse(value) as Record<string, string>;
+    const parsed = JSON.parse(value) as unknown;
+    return isStringRecord(parsed) ? parsed : {};
   } catch {
     return {};
   }
@@ -64,7 +61,7 @@ export function extractLogsFromDsQuery(response: {
   results: {
     A: {
       frames?: Array<{
-        schema: { fields: Array<{ name: string; type?: string }> };
+        schema: { fields: Array<{ name: string; type?: string; labels?: Record<string, string> }> };
         data: { values: unknown[][] };
       }>;
     };
@@ -81,15 +78,14 @@ export function extractLogsFromDsQuery(response: {
     const lineIndex = fields.findIndex(
       (field) => field.name === "body" || field.name === "Line" || field.name === "line",
     );
-    const labelsIndex = fields.findIndex(
-      (field) => field.name === "labels" || field.name === "labelTypes",
-    );
+    const labelsIndex = fields.findIndex((field) => field.name === "labels");
 
     const timestamps = (timeIndex >= 0 ? values[timeIndex] : []) as Array<string | number>;
     const lines = (lineIndex >= 0 ? values[lineIndex] : []) as string[];
     const labelValues = (labelsIndex >= 0 ? values[labelsIndex] : []) as Array<
       string | Record<string, string>
     >;
+    const streamLabels = lineIndex >= 0 ? fields[lineIndex]?.labels : undefined;
 
     for (const [index, line] of lines.entries()) {
       const structured = parseStructuredLogLine(line);
@@ -97,7 +93,7 @@ export function extractLogsFromDsQuery(response: {
         timestamp: String(timestamps[index] ?? ""),
         line,
         ...structured,
-        labels: labelValues[index] ? parseLabel(labelValues[index]) : {},
+        labels: labelValues[index] ? parseLabel(labelValues[index]) : (streamLabels ?? {}),
       });
     }
   }
@@ -163,7 +159,7 @@ const queryCommand = Command.make(
 
       yield* Console.log(formatOutput(result, format));
     }).pipe(
-      Effect.catch((error) =>
+      Effect.catchTag("ObservabilityToolError", (error) =>
         Effect.gen(function* () {
           const result = {
             success: false,

package/src/observability-tool/types.ts

@@ -8,6 +8,21 @@ export type ObservabilityEnvConfig = {
   tempoUid: string;
 };
 
+export type LogLine = {
+  readonly timestamp: string;
+  readonly line: string;
+  readonly body?: string;
+  readonly severity?: string;
+  readonly attributes?: Record<string, unknown>;
+  readonly labels: Record<string, string>;
+};
+
+export type StructuredLogLine = {
+  readonly body?: string;
+  readonly severity?: string;
+  readonly attributes?: Record<string, unknown>;
+};
+
 export type GrafanaDatasource = {
   uid: string;
   name: string;