wp-studio 1.8.0 → 1.8.1

package/dist/cli/wp-files/sqlite-database-integration/wp-includes/database/sqlite/class-wp-pdo-mysql-on-sqlite.php

@@ -2308,6 +2308,38 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 			throw $this->new_access_denied_to_information_schema_exception();
 		}
 
+		/*
+		 * SQLite doesn't support DELETE with ORDER BY/LIMIT.
+		 * We need to use a subquery to emulate this behavior.
+		 *
+		 * For instance, the following query:
+		 *   DELETE FROM t WHERE c = 2 LIMIT 1;
+		 * Will be rewritten to:
+		 *   DELETE FROM t WHERE rowid IN ( SELECT rowid FROM t WHERE c = 2 LIMIT 1 );
+		 */
+		$has_order = $node->has_child_node( 'orderClause' );
+		$has_limit = $node->has_child_node( 'simpleLimitClause' );
+		if ( $has_order || $has_limit ) {
+			$where_subquery = 'SELECT rowid FROM ' . $this->translate_sequence(
+				array(
+					$table_ref,
+					$node->get_first_child_node( 'tableAlias' ),
+					$node->get_first_child_node( 'whereClause' ),
+					$node->get_first_child_node( 'orderClause' ),
+					$node->get_first_child_node( 'simpleLimitClause' ),
+				)
+			);
+
+			$query = sprintf(
+				'DELETE FROM %s WHERE rowid IN ( %s )',
+				$this->translate( $table_ref ),
+				$where_subquery
+			);
+
+			$this->last_result_statement = $this->execute_sqlite_query( $query );
+			return;
+		}
+
 		$query                       = $this->translate( $node );
 		$this->last_result_statement = $this->execute_sqlite_query( $query );
 	}
@@ -2378,6 +2410,9 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		foreach ( $constraint_queries as $query ) {
 			$this->execute_sqlite_query( $query );
 		}
+
+		// Apply AUTO_INCREMENT = N table option, if any.
+		$this->apply_auto_increment_table_option( $table_is_temporary, $table_name, $node );
 	}
 
 	/**
@@ -2451,8 +2486,18 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 			}
 		}
 
-		$this->information_schema_builder->record_alter_table( $node );
-		$this->recreate_table_from_information_schema( $table_is_temporary, $table_name, $column_map );
+		/*
+		 * Skip the expensive table rebuild when the statement only carries
+		 * table options (e.g. ALTER TABLE t AUTO_INCREMENT = N). These don't
+		 * change the schema, so the recreate would be a pointless full copy.
+		 */
+		if ( count( $node->get_descendant_nodes( 'alterListItem' ) ) > 0 ) {
+			$this->information_schema_builder->record_alter_table( $node );
+			$this->recreate_table_from_information_schema( $table_is_temporary, $table_name, $column_map );
+		}
+
+		// Apply AUTO_INCREMENT = N table option, if any.
+		$this->apply_auto_increment_table_option( $table_is_temporary, $table_name, $node );
 
 		// @TODO: Consider using a "fast path" for ALTER TABLE statements that
 		//        consist only of operations that SQLite's ALTER TABLE supports.
@@ -2958,41 +3003,64 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		// LIKE and WHERE clauses.
 		$like_or_where = $node->get_first_child_node( 'likeOrWhere' );
 		if ( null !== $like_or_where ) {
-			$condition = $this->translate_show_like_or_where_condition( $like_or_where, 'table_name' );
+			$condition = $this->translate_show_like_or_where_condition( $like_or_where, 'Name' );
 		}
 
-		// Fetch table information.
-		$tables_tables = $this->information_schema_builder->get_table_name(
-			false, // SHOW TABLE STATUS lists only non-temporary tables.
-			'tables'
+		// SHOW TABLE STATUS lists only non-temporary tables.
+		$tables_table  = $this->information_schema_builder->get_table_name( false, 'tables' );
+		$columns_table = $this->information_schema_builder->get_table_name( false, 'columns' );
+
+		// Compose a subquery to compute auto-increment values.
+		$has_sequence_table = (bool) $this->execute_sqlite_query(
+			"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'"
+		)->fetchColumn();
+
+		$auto_increment_subquery = sprintf(
+			"(
+				SELECT COALESCE(s.seq + 1, 1)
+				FROM %s AS c
+				%s
+				WHERE c.extra = 'auto_increment'
+				AND c.table_schema = t.table_schema
+				AND c.table_name = t.table_name
+			)",
+			$this->quote_sqlite_identifier( $columns_table ),
+			$has_sequence_table
+				? 'LEFT JOIN main.sqlite_sequence AS s ON s.name = c.table_name'
+				: 'LEFT JOIN (SELECT 0 AS seq) AS s'
 		);
-		$query         = sprintf(
-			'SELECT
-				table_name AS `Name`,
-				engine AS `Engine`,
-				version AS `Version`,
-				row_format AS `Row_format`,
-				table_rows AS `Rows`,
-				avg_row_length AS `Avg_row_length`,
-				data_length AS `Data_length`,
-				max_data_length AS `Max_data_length`,
-				index_length AS `Index_length`,
-				data_free AS `Data_free`,
-				auto_increment AS `Auto_increment`,
-				create_time AS `Create_time`,
-				update_time AS `Update_time`,
-				check_time AS `Check_time`,
-				table_collation AS `Collation`,
-				checksum AS `Checksum`,
-				create_options AS `Create_options`,
-				table_comment AS `Comment`
-			FROM %s
-			WHERE table_schema = ? %s
-			ORDER BY table_name',
-			$this->quote_sqlite_identifier( $tables_tables ),
+
+		$query  = sprintf(
+			'SELECT * FROM (
+				SELECT
+					table_name AS `Name`,
+					engine AS `Engine`,
+					version AS `Version`,
+					row_format AS `Row_format`,
+					table_rows AS `Rows`,
+					avg_row_length AS `Avg_row_length`,
+					data_length AS `Data_length`,
+					max_data_length AS `Max_data_length`,
+					index_length AS `Index_length`,
+					data_free AS `Data_free`,
+					%s AS `Auto_increment`,
+					create_time AS `Create_time`,
+					update_time AS `Update_time`,
+					check_time AS `Check_time`,
+					table_collation AS `Collation`,
+					checksum AS `Checksum`,
+					create_options AS `Create_options`,
+					table_comment AS `Comment`
+				FROM %s AS t
+				WHERE table_schema = ?
+			)
+			WHERE 1 %s
+			ORDER BY `Name`',
+			$auto_increment_subquery,
+			$this->quote_sqlite_identifier( $tables_table ),
 			$condition ?? ''
 		);
-		$params        = array(
+		$params = array(
 			$this->get_saved_db_name( $database ),
 		);
 
@@ -3892,9 +3960,9 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 				return 'AUTOINCREMENT';
 			case WP_MySQL_Lexer::BINARY_SYMBOL:
 				/*
-				 * There is no "BINARY expr" equivalent in SQLite. We look for the
-				 * keyword from a higher level to respect it in particular cases
-				 * (REGEXP, LIKE, etc.) and then remove it from the output here.
+				 * "BINARY expr" is translated in "translate_simple_expr_body()".
+				 * Returning null here is a safety net for any unhandled context
+				 * where a bare BINARY token would otherwise leak into the output.
 				 */
 				return null;
 			case WP_MySQL_Lexer::SQL_CALC_FOUND_ROWS_SYMBOL:
@@ -4242,6 +4310,24 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 			);
 		}
 
+		/*
+		 * Translate "BINARY expr" to "expr COLLATE BINARY".
+		 *
+		 * The MySQL BINARY operator enforces byte-by-byte string comparison.
+		 * In SQLite, COLLATE BINARY is equivalent in comparison contexts.
+		 */
+		if ( null !== $token && WP_MySQL_Lexer::BINARY_SYMBOL === $token->id ) {
+			$expr = $node->get_first_child_node( 'simpleExpr' );
+			return sprintf( '%s COLLATE BINARY', $this->translate( $expr ) );
+		}
+
+		// Translate "CAST(expr AS type)" to its SQLite equivalent.
+		if ( null !== $token && WP_MySQL_Lexer::CAST_SYMBOL === $token->id ) {
+			$expr      = $node->get_first_child_node( 'expr' );
+			$cast_type = $node->get_first_child_node( 'castType' );
+			return $this->translate_cast_expr( $expr, $cast_type );
+		}
+
 		/**
 		 * Translate MySQL CONVERT() expression.
 		 *
@@ -4250,23 +4336,44 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		 *   2. CONVERT(expr USING charset): Converts the character set.
 		 */
 		if ( null !== $token && WP_MySQL_Lexer::CONVERT_SYMBOL === $token->id ) {
-			$expr      = $this->translate( $node->get_first_child_node( 'expr' ) );
+			$expr      = $node->get_first_child_node( 'expr' );
 			$cast_type = $node->get_first_child_node( 'castType' );
 
 			if ( null !== $cast_type ) {
 				// CONVERT(expr, type): Translate to cast expression.
 				// TODO: Emulate UNSIGNED cast. SQLite has no unsigned integer type.
-				return sprintf( 'CAST(%s AS %s)', $expr, $this->translate( $cast_type ) );
+				return $this->translate_cast_expr( $expr, $cast_type );
 			} else {
 				// CONVERT(expr USING charset): Keep "expr" as is (no SQLite support).
 				// TODO: Consider rejecting UTF-8-incompatible charasets.
-				return $expr;
+				return $this->translate( $expr );
 			}
 		}
 
 		return $this->translate_sequence( $node->get_children() );
 	}
 
+	/**
+	 * Translate a MySQL CAST expression to SQLite.
+	 *
+	 * Shared by the CAST(expr AS type) and CONVERT(expr, type) forms.
+	 *
+	 * @param  WP_Parser_Node $expr      The "expr" AST node.
+	 * @param  WP_Parser_Node $cast_type The "castType" AST node.
+	 * @return string                    The translated SQLite expression.
+	 */
+	private function translate_cast_expr( WP_Parser_Node $expr, WP_Parser_Node $cast_type ): string {
+		/*
+		 * Translate "CAST(expr AS BINARY)" to "CAST(expr AS TEXT) COLLATE BINARY".
+		 * Emitting "CAST(expr AS BLOB)" would break equality against TEXT values
+		 * due to SQLite's storage-class ordering (BLOB > TEXT).
+		 */
+		if ( $cast_type->has_child_token( WP_MySQL_Lexer::BINARY_SYMBOL ) ) {
+			return sprintf( 'CAST(%s AS TEXT) COLLATE BINARY', $this->translate( $expr ) );
+		}
+		return sprintf( 'CAST(%s AS %s)', $this->translate( $expr ), $this->translate( $cast_type ) );
+	}
+
 	/**
 	 * Translate a MySQL LIKE expression to SQLite.
 	 *
@@ -4625,11 +4732,20 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		 *
 		 * For example, for "SELECT 'abc'", the resulting column name is "abc"
 		 * in MySQL, but would be "'abc'" in SQLite if an alias was not used.
+		 *
+		 * Descend the AST until we reach a textStringLiteral. If at any level
+		 * we don't have a single child node, bail out; it's not a bare literal.
 		 */
-		$text_string_literal    = $node->get_first_descendant_node( 'textStringLiteral' );
-		$is_text_string_literal = $text_string_literal && $item === $this->translate( $text_string_literal );
-		if ( $is_text_string_literal ) {
-			$alias = $text_string_literal->get_first_child_token()->get_value();
+		$current = $node;
+		while ( 'textStringLiteral' !== $current->rule_name ) {
+			$children = $current->get_children();
+			if ( 1 !== count( $children ) || ! $children[0] instanceof WP_Parser_Node ) {
+				break;
+			}
+			$current = $children[0];
+		}
+		if ( 'textStringLiteral' === $current->rule_name ) {
+			$alias = $current->get_first_child_token()->get_value();
 
 			// When the literal value contains a NULL byte, MySQL truncates the
 			// resulting identifier at the position of the first one of them.
@@ -4697,7 +4813,7 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		$table_name  = $this->unquote_sqlite_identifier( $this->translate( $table ) );
 
 		// When the table reference targets an information schema table,
-		// we need to inject the configured database name dynamically.
+		// we need to inject some additional values dynamically.
 		if (
 			( null === $schema_name && 'information_schema' === $this->db_name )
 			|| ( null !== $schema_name && 'information_schema' === strtolower( $schema_name ) )
@@ -4743,14 +4859,40 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 			$expanded_list = array();
 			foreach ( $columns as $column ) {
 				$quoted_column = $this->quote_sqlite_identifier( $column );
-				if ( isset( $information_schema_db_column_map[ strtoupper( $column ) ] ) ) {
+				if ( isset( $information_schema_db_column_map[ $column ] ) ) {
+					// Replace the database name with the configured database name.
 					$expanded_list[] = sprintf(
 						"CASE WHEN %s = 'information_schema' THEN %s ELSE %s END AS %s",
 						$quoted_column,
 						$quoted_column,
 						$this->quote_sqlite_value( $this->main_db_name ),
-						strtoupper( $quoted_column )
+						$quoted_column
 					);
+				} elseif ( 'tables' === $table_name && 'AUTO_INCREMENT' === $column ) {
+					// Inject the auto-increment values.
+					$columns_table      = $this->information_schema_builder->get_table_name( false, 'columns' );
+					$has_sequence_table = (bool) $this->execute_sqlite_query(
+						"SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'sqlite_sequence'"
+					)->fetchColumn();
+
+					$auto_increment_subquery = sprintf(
+						"(
+							SELECT COALESCE(s.seq + 1, 1)
+							FROM %s AS c
+							%s
+							WHERE c.extra = 'auto_increment'
+							AND c.table_schema = %s.table_schema
+							AND c.table_name = %s.table_name
+						)",
+						$this->quote_sqlite_identifier( $columns_table ),
+						$has_sequence_table
+							? 'LEFT JOIN main.sqlite_sequence AS s ON s.name = c.table_name'
+							: 'LEFT JOIN (SELECT 0 AS seq) AS s',
+						$this->quote_sqlite_identifier( $table_name ),
+						$this->quote_sqlite_identifier( $table_name )
+					);
+
+					$expanded_list[] = sprintf( '%s AS %s', $auto_increment_subquery, $quoted_column );
 				} else {
 					$expanded_list[] = $quoted_column;
 				}
@@ -4867,6 +5009,83 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		// @TODO: Triggers and views.
 	}
 
+	/**
+	 * Apply the AUTO_INCREMENT table option from a CREATE TABLE or ALTER TABLE
+	 * statement by adjusting the row in SQLite's "sqlite_sequence" table.
+	 *
+	 * @param bool           $table_is_temporary Whether the table is temporary.
+	 * @param string         $table_name         The table name.
+	 * @param WP_Parser_Node $node               The "createStatement" or "alterStatement" AST node.
+	 */
+	private function apply_auto_increment_table_option(
+		bool $table_is_temporary,
+		string $table_name,
+		WP_Parser_Node $node
+	): void {
+		// Find the last AUTO_INCREMENT = N option (MySQL uses the last one).
+		$value = null;
+		foreach ( $node->get_descendant_nodes( 'createTableOption' ) as $option ) {
+			if ( ! $option->has_child_token( WP_MySQL_Lexer::AUTO_INCREMENT_SYMBOL ) ) {
+				continue;
+			}
+			$number_node = $option->get_first_child_node( 'ulonglong_number' );
+			if ( null === $number_node ) {
+				continue;
+			}
+			$value = (int) $number_node->get_first_descendant_token()->get_value();
+		}
+		if ( null === $value ) {
+			return;
+		}
+
+		// Find the AUTO_INCREMENT column.
+		$columns_table = $this->information_schema_builder->get_table_name( $table_is_temporary, 'columns' );
+		$auto_column   = $this->execute_sqlite_query(
+			sprintf(
+				"SELECT column_name FROM %s
+				WHERE table_schema = ?
+				AND table_name = ?
+				AND extra = 'auto_increment'",
+				$this->quote_sqlite_identifier( $columns_table )
+			),
+			array( $this->get_saved_db_name(), $table_name )
+		)->fetchColumn();
+		if ( false === $auto_column ) {
+			return;
+		}
+
+		/*
+		 * Prepare an expression for the sequence value.
+		 *   1. Use N - 1. MySQL stores the next value, SQLite the last one.
+		 *   2. Clamp to MAX(col) like MySQL (we can't go below existing values).
+		 *
+		 * The value is inlined as an integer literal because PDO binds PHP ints
+		 * as TEXT, and SQLite's type affinity ranks TEXT above INTEGER in MAX().
+		 */
+		$schema   = $table_is_temporary ? 'temp' : 'main';
+		$seq_expr = sprintf(
+			'MAX(%d, COALESCE((SELECT MAX(%s) FROM %s), 0))',
+			$value - 1,
+			$this->quote_sqlite_identifier( $auto_column ),
+			$this->quote_sqlite_identifier( $table_name )
+		);
+
+		// Update the value in the "sqlite_sequence" table.
+		$updated = $this->execute_sqlite_query(
+			sprintf( 'UPDATE %s.sqlite_sequence SET seq = %s WHERE name = ?', $schema, $seq_expr ),
+			array( $table_name )
+		)->rowCount();
+
+		// If the sequence value does not exist yet, insert a new row.
+		// SQLite reports matched (not affected) rows, so the 0 check is safe.
+		if ( 0 === $updated ) {
+			$this->execute_sqlite_query(
+				sprintf( 'INSERT INTO %s.sqlite_sequence (name, seq) VALUES (?, %s)', $schema, $seq_expr ),
+				array( $table_name )
+			);
+		}
+	}
+
 	/**
 	 * Translate a MySQL SHOW LIKE ... or SHOW WHERE ... condition to SQLite.
 	 *
@@ -6303,7 +6522,8 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		)->fetchAll( PDO::FETCH_ASSOC );
 
 		// 6. Generate CREATE TABLE statement columns.
-		$rows = array();
+		$rows               = array();
+		$has_auto_increment = false;
 		foreach ( $column_info as $column ) {
 			$sql  = '  ';
 			$sql .= $this->quote_mysql_identifier( $column['COLUMN_NAME'] );
@@ -6315,7 +6535,8 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 				$sql .= ' NULL';
 			}
 			if ( 'auto_increment' === $column['EXTRA'] ) {
-				$sql .= ' AUTO_INCREMENT';
+				$has_auto_increment = true;
+				$sql               .= ' AUTO_INCREMENT';
 			}
 
 			// Handle DEFAULT CURRENT_TIMESTAMP. This works only with timestamp
@@ -6454,6 +6675,28 @@ class WP_PDO_MySQL_On_SQLite extends PDO {
 		$sql .= implode( ",\n", $rows );
 		$sql .= "\n)";
 		$sql .= sprintf( ' ENGINE=%s', $table_info['ENGINE'] );
+
+		// Add "AUTO_INCREMENT=N" if a sequence exists and has been advanced.
+		if ( $has_auto_increment ) {
+			try {
+				$seq = (int) $this->execute_sqlite_query(
+					sprintf(
+						'SELECT seq FROM %s.sqlite_sequence WHERE name = ?',
+						$table_is_temporary ? 'temp' : 'main'
+					),
+					array( $table_name )
+				)->fetchColumn();
+			} catch ( PDOException $e ) {
+				if ( ! str_contains( $e->getMessage(), 'no such table' ) ) {
+					throw $e;
+				}
+				$seq = 0;
+			}
+			if ( $seq > 0 ) {
+				$sql .= sprintf( ' AUTO_INCREMENT=%d', $seq + 1 );
+			}
+		}
+
 		$sql .= sprintf( ' DEFAULT CHARSET=%s', $charset );
 		$sql .= sprintf( ' COLLATE=%s', $collation );
 		if ( '' !== $table_info['TABLE_COMMENT'] ) {

package/dist/cli/wp-files/sqlite-database-integration/wp-includes/database/version.php

@@ -5,4 +5,4 @@
  *
  * This constant needs to be updated on plugin release!
  */
-define( 'SQLITE_DRIVER_VERSION', '3.0.0-rc.1' );
+define( 'SQLITE_DRIVER_VERSION', '3.0.0-rc.2' );

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "wp-studio",
 	"author": "Automattic Inc.",
-	"version": "1.8.0",
+	"version": "1.8.1",
 	"productName": "Studio CLI",
 	"description": "WordPress Studio CLI",
 	"license": "GPL-2.0-or-later",
@@ -24,27 +24,27 @@
 		"directory": "apps/cli"
 	},
 	"dependencies": {
-		"@anthropic-ai/claude-agent-sdk": "^0.2.45",
+		"@anthropic-ai/claude-agent-sdk": "^0.2.117",
 		"@inquirer/prompts": "^8.3.2",
 		"@mariozechner/pi-tui": "^0.54.0",
 		"@modelcontextprotocol/sdk": "^1.27.1",
-		"@php-wasm/node": "3.1.20",
-		"@php-wasm/universal": "3.1.20",
-		"@php-wasm/util": "3.1.20",
+		"@php-wasm/node": "3.1.21",
+		"@php-wasm/universal": "3.1.21",
+		"@php-wasm/util": "3.1.21",
 		"@vscode/sudo-prompt": "^9.3.2",
 		"@wordpress/i18n": "^6.14.0",
-		"@wp-playground/blueprints": "3.1.20",
-		"@wp-playground/cli": "3.1.20",
-		"@wp-playground/common": "3.1.20",
-		"@wp-playground/storage": "3.1.20",
-		"@wp-playground/wordpress": "3.1.20",
+		"@wp-playground/blueprints": "^3.1.21",
+		"@wp-playground/cli": "3.1.21",
+		"@wp-playground/common": "3.1.21",
+		"@wp-playground/storage": "3.1.21",
+		"@wp-playground/wordpress": "3.1.21",
 		"archiver": "^7.0.1",
 		"atomically": "^2.1.1",
 		"cli-table3": "^0.6.5",
 		"fs-extra": "^11.3.4",
 		"http-proxy": "^1.18.1",
 		"ignore": "^7.0.5",
-		"node-forge": "^1.3.3",
+		"node-forge": "^1.4.0",
 		"patch-package": "^8.0.1",
 		"picospinner": "^3.0.0",
 		"playwright": "^1.52.0",

package/dist/cli/status-DNyCON-I.mjs

@@ -1,42 +0,0 @@
-import { A as AuthCommandLoggerAction, r as readAuthToken, g as getUserInfo } from "./index-CopZPgb8.mjs";
-import { __, sprintf } from "@wordpress/i18n";
-import { c as Logger, L as LoggerError } from "./certificate-manager-v-yNLDFJ.mjs";
-async function runCommand() {
-  const logger = new Logger();
-  logger.reportStart(AuthCommandLoggerAction.STATUS_CHECK, __("Checking authentication status…"));
-  try {
-    const token = await readAuthToken();
-    if (!token) {
-      logger.reportError(new LoggerError(__("Authentication token is invalid or expired")));
-      return;
-    }
-    const userData = await getUserInfo(token.accessToken);
-    logger.reportSuccess(
-      sprintf(__("Authenticated with WordPress.com as `%s`"), userData.username)
-    );
-  } catch (error) {
-    if (error instanceof LoggerError) {
-      logger.reportError(error);
-    } else {
-      logger.reportError(new LoggerError(__("Failed to check authentication status"), error));
-    }
-  }
-}
-const registerCommand = (yargs) => {
-  return yargs.command({
-    command: "status",
-    describe: __("Check authentication status"),
-    builder: (yargs2) => {
-      return yargs2.option("path", {
-        hidden: true
-      });
-    },
-    handler: async () => {
-      await runCommand();
-    }
-  });
-};
-export {
-  registerCommand,
-  runCommand
-};